﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;



namespace Huanan.Algorithm.DSP
{

    public class IntVector : global::System.IDisposable, global::System.Collections.IEnumerable, global::System.Collections.Generic.IList<int>
    {
        private global::System.Runtime.InteropServices.HandleRef swigCPtr;
        protected bool swigCMemOwn;

        internal IntVector(global::System.IntPtr cPtr, bool cMemoryOwn)
        {
            swigCMemOwn = cMemoryOwn;
            swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
        }

        internal static global::System.Runtime.InteropServices.HandleRef getCPtr(IntVector obj)
        {
            return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
        }

        ~IntVector()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            global::System.GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            lock (this)
            {
                if (swigCPtr.Handle != global::System.IntPtr.Zero)
                {
                    if (swigCMemOwn)
                    {
                        swigCMemOwn = false;
                        HNAlgoNativePINVOKE.delete_IntVector(swigCPtr);
                    }
                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
                }
            }
        }

        public IntVector(global::System.Collections.IEnumerable c) : this()
        {
            if (c == null)
                throw new global::System.ArgumentNullException("c");
            foreach (int element in c)
            {
                this.Add(element);
            }
        }

        public IntVector(global::System.Collections.Generic.IEnumerable<int> c) : this()
        {
            if (c == null)
                throw new global::System.ArgumentNullException("c");
            foreach (int element in c)
            {
                this.Add(element);
            }
        }

        public bool IsFixedSize
        {
            get
            {
                return false;
            }
        }

        public bool IsReadOnly
        {
            get
            {
                return false;
            }
        }

        public int this[int index]
        {
            get
            {
                return getitem(index);
            }
            set
            {
                setitem(index, value);
            }
        }

        public int Capacity
        {
            get
            {
                return (int)capacity();
            }
            set
            {
                if (value < size())
                    throw new global::System.ArgumentOutOfRangeException("Capacity");
                reserve((uint)value);
            }
        }

        public int Count
        {
            get
            {
                return (int)size();
            }
        }

        public bool IsSynchronized
        {
            get
            {
                return false;
            }
        }

        public void CopyTo(int[] array)
        {
            CopyTo(0, array, 0, this.Count);
        }

        public void CopyTo(int[] array, int arrayIndex)
        {
            CopyTo(0, array, arrayIndex, this.Count);
        }

        public void CopyTo(int index, int[] array, int arrayIndex, int count)
        {
            if (array == null)
                throw new global::System.ArgumentNullException("array");
            if (index < 0)
                throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero");
            if (arrayIndex < 0)
                throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
            if (count < 0)
                throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero");
            if (array.Rank > 1)
                throw new global::System.ArgumentException("Multi dimensional array.", "array");
            if (index + count > this.Count || arrayIndex + count > array.Length)
                throw new global::System.ArgumentException("Number of elements to copy is too large.");
            for (int i = 0; i < count; i++)
                array.SetValue(getitemcopy(index + i), arrayIndex + i);
        }

        public int[] ToArray()
        {
            int[] array = new int[this.Count];
            this.CopyTo(array);
            return array;
        }

        global::System.Collections.Generic.IEnumerator<int> global::System.Collections.Generic.IEnumerable<int>.GetEnumerator()
        {
            return new IntVectorEnumerator(this);
        }

        global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
        {
            return new IntVectorEnumerator(this);
        }

        public IntVectorEnumerator GetEnumerator()
        {
            return new IntVectorEnumerator(this);
        }

        // Type-safe enumerator
        /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
        /// whenever the collection is modified. This has been done for changes in the size of the
        /// collection but not when one of the elements of the collection is modified as it is a bit
        /// tricky to detect unmanaged code that modifies the collection under our feet.
        public sealed class IntVectorEnumerator : global::System.Collections.IEnumerator
          , global::System.Collections.Generic.IEnumerator<int>
        {
            private IntVector collectionRef;
            private int currentIndex;
            private object currentObject;
            private int currentSize;

            public IntVectorEnumerator(IntVector collection)
            {
                collectionRef = collection;
                currentIndex = -1;
                currentObject = null;
                currentSize = collectionRef.Count;
            }

            // Type-safe iterator Current
            public int Current
            {
                get
                {
                    if (currentIndex == -1)
                        throw new global::System.InvalidOperationException("Enumeration not started.");
                    if (currentIndex > currentSize - 1)
                        throw new global::System.InvalidOperationException("Enumeration finished.");
                    if (currentObject == null)
                        throw new global::System.InvalidOperationException("Collection modified.");
                    return (int)currentObject;
                }
            }

            // Type-unsafe IEnumerator.Current
            object global::System.Collections.IEnumerator.Current
            {
                get
                {
                    return Current;
                }
            }

            public bool MoveNext()
            {
                int size = collectionRef.Count;
                bool moveOkay = (currentIndex + 1 < size) && (size == currentSize);
                if (moveOkay)
                {
                    currentIndex++;
                    currentObject = collectionRef[currentIndex];
                }
                else
                {
                    currentObject = null;
                }
                return moveOkay;
            }

            public void Reset()
            {
                currentIndex = -1;
                currentObject = null;
                if (collectionRef.Count != currentSize)
                {
                    throw new global::System.InvalidOperationException("Collection modified.");
                }
            }

            public void Dispose()
            {
                currentIndex = -1;
                currentObject = null;
            }
        }

        public void Clear()
        {
            HNAlgoNativePINVOKE.IntVector_Clear(swigCPtr);
        }

        public void Add(int x)
        {
            HNAlgoNativePINVOKE.IntVector_Add(swigCPtr, x);
        }

        private uint size()
        {
            uint ret = HNAlgoNativePINVOKE.IntVector_size(swigCPtr);
            return ret;
        }

        private uint capacity()
        {
            uint ret = HNAlgoNativePINVOKE.IntVector_capacity(swigCPtr);
            return ret;
        }

        private void reserve(uint n)
        {
            HNAlgoNativePINVOKE.IntVector_reserve(swigCPtr, n);
        }

        public IntVector() : this(HNAlgoNativePINVOKE.new_IntVector__SWIG_0(), true)
        {
        }

        public IntVector(IntVector other) : this(HNAlgoNativePINVOKE.new_IntVector__SWIG_1(IntVector.getCPtr(other)), true)
        {
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public IntVector(int capacity) : this(HNAlgoNativePINVOKE.new_IntVector__SWIG_2(capacity), true)
        {
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        private int getitemcopy(int index)
        {
            int ret = HNAlgoNativePINVOKE.IntVector_getitemcopy(swigCPtr, index);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        private int getitem(int index)
        {
            int ret = HNAlgoNativePINVOKE.IntVector_getitem(swigCPtr, index);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        private void setitem(int index, int val)
        {
            HNAlgoNativePINVOKE.IntVector_setitem(swigCPtr, index, val);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void AddRange(IntVector values)
        {
            HNAlgoNativePINVOKE.IntVector_AddRange(swigCPtr, IntVector.getCPtr(values));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public IntVector GetRange(int index, int count)
        {
            global::System.IntPtr cPtr = HNAlgoNativePINVOKE.IntVector_GetRange(swigCPtr, index, count);
            IntVector ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVector(cPtr, true);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        public void Insert(int index, int x)
        {
            HNAlgoNativePINVOKE.IntVector_Insert(swigCPtr, index, x);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void InsertRange(int index, IntVector values)
        {
            HNAlgoNativePINVOKE.IntVector_InsertRange(swigCPtr, index, IntVector.getCPtr(values));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void RemoveAt(int index)
        {
            HNAlgoNativePINVOKE.IntVector_RemoveAt(swigCPtr, index);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void RemoveRange(int index, int count)
        {
            HNAlgoNativePINVOKE.IntVector_RemoveRange(swigCPtr, index, count);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public static IntVector Repeat(int value, int count)
        {
            global::System.IntPtr cPtr = HNAlgoNativePINVOKE.IntVector_Repeat(value, count);
            IntVector ret = (cPtr == global::System.IntPtr.Zero) ? null : new IntVector(cPtr, true);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        public void Reverse()
        {
            HNAlgoNativePINVOKE.IntVector_Reverse__SWIG_0(swigCPtr);
        }

        public void Reverse(int index, int count)
        {
            HNAlgoNativePINVOKE.IntVector_Reverse__SWIG_1(swigCPtr, index, count);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void SetRange(int index, IntVector values)
        {
            HNAlgoNativePINVOKE.IntVector_SetRange(swigCPtr, index, IntVector.getCPtr(values));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public bool Contains(int value)
        {
            bool ret = HNAlgoNativePINVOKE.IntVector_Contains(swigCPtr, value);
            return ret;
        }

        public int IndexOf(int value)
        {
            int ret = HNAlgoNativePINVOKE.IntVector_IndexOf(swigCPtr, value);
            return ret;
        }

        public int LastIndexOf(int value)
        {
            int ret = HNAlgoNativePINVOKE.IntVector_LastIndexOf(swigCPtr, value);
            return ret;
        }

        public bool Remove(int value)
        {
            bool ret = HNAlgoNativePINVOKE.IntVector_Remove(swigCPtr, value);
            return ret;
        }

    }

}
namespace Huanan.Algorithm.DSP
{

    public class DoubleVector : global::System.IDisposable, global::System.Collections.IEnumerable, global::System.Collections.Generic.IList<double>
    {
        private global::System.Runtime.InteropServices.HandleRef swigCPtr;
        protected bool swigCMemOwn;

        internal DoubleVector(global::System.IntPtr cPtr, bool cMemoryOwn)
        {
            swigCMemOwn = cMemoryOwn;
            swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
        }

        internal static global::System.Runtime.InteropServices.HandleRef getCPtr(DoubleVector obj)
        {
            return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
        }

        ~DoubleVector()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            global::System.GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            lock (this)
            {
                if (swigCPtr.Handle != global::System.IntPtr.Zero)
                {
                    if (swigCMemOwn)
                    {
                        swigCMemOwn = false;
                        HNAlgoNativePINVOKE.delete_DoubleVector(swigCPtr);
                    }
                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
                }
            }
        }

        public DoubleVector(global::System.Collections.IEnumerable c) : this()
        {
            if (c == null)
                throw new global::System.ArgumentNullException("c");
            foreach (double element in c)
            {
                this.Add(element);
            }
        }

        public DoubleVector(global::System.Collections.Generic.IEnumerable<double> c) : this()
        {
            if (c == null)
                throw new global::System.ArgumentNullException("c");
            foreach (double element in c)
            {
                this.Add(element);
            }
        }

        public bool IsFixedSize
        {
            get
            {
                return false;
            }
        }

        public bool IsReadOnly
        {
            get
            {
                return false;
            }
        }

        public double this[int index]
        {
            get
            {
                return getitem(index);
            }
            set
            {
                setitem(index, value);
            }
        }

        public int Capacity
        {
            get
            {
                return (int)capacity();
            }
            set
            {
                if (value < size())
                    throw new global::System.ArgumentOutOfRangeException("Capacity");
                reserve((uint)value);
            }
        }

        public int Count
        {
            get
            {
                return (int)size();
            }
        }

        public bool IsSynchronized
        {
            get
            {
                return false;
            }
        }

        public void CopyTo(double[] array)
        {
            CopyTo(0, array, 0, this.Count);
        }

        public void CopyTo(double[] array, int arrayIndex)
        {
            CopyTo(0, array, arrayIndex, this.Count);
        }

        public void CopyTo(int index, double[] array, int arrayIndex, int count)
        {
            if (array == null)
                throw new global::System.ArgumentNullException("array");
            if (index < 0)
                throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero");
            if (arrayIndex < 0)
                throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
            if (count < 0)
                throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero");
            if (array.Rank > 1)
                throw new global::System.ArgumentException("Multi dimensional array.", "array");
            if (index + count > this.Count || arrayIndex + count > array.Length)
                throw new global::System.ArgumentException("Number of elements to copy is too large.");
            for (int i = 0; i < count; i++)
                array.SetValue(getitemcopy(index + i), arrayIndex + i);
        }

        public double[] ToArray()
        {
            double[] array = new double[this.Count];
            this.CopyTo(array);
            return array;
        }

        global::System.Collections.Generic.IEnumerator<double> global::System.Collections.Generic.IEnumerable<double>.GetEnumerator()
        {
            return new DoubleVectorEnumerator(this);
        }

        global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
        {
            return new DoubleVectorEnumerator(this);
        }

        public DoubleVectorEnumerator GetEnumerator()
        {
            return new DoubleVectorEnumerator(this);
        }

        // Type-safe enumerator
        /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
        /// whenever the collection is modified. This has been done for changes in the size of the
        /// collection but not when one of the elements of the collection is modified as it is a bit
        /// tricky to detect unmanaged code that modifies the collection under our feet.
        public sealed class DoubleVectorEnumerator : global::System.Collections.IEnumerator
          , global::System.Collections.Generic.IEnumerator<double>
        {
            private DoubleVector collectionRef;
            private int currentIndex;
            private object currentObject;
            private int currentSize;

            public DoubleVectorEnumerator(DoubleVector collection)
            {
                collectionRef = collection;
                currentIndex = -1;
                currentObject = null;
                currentSize = collectionRef.Count;
            }

            // Type-safe iterator Current
            public double Current
            {
                get
                {
                    if (currentIndex == -1)
                        throw new global::System.InvalidOperationException("Enumeration not started.");
                    if (currentIndex > currentSize - 1)
                        throw new global::System.InvalidOperationException("Enumeration finished.");
                    if (currentObject == null)
                        throw new global::System.InvalidOperationException("Collection modified.");
                    return (double)currentObject;
                }
            }

            // Type-unsafe IEnumerator.Current
            object global::System.Collections.IEnumerator.Current
            {
                get
                {
                    return Current;
                }
            }

            public bool MoveNext()
            {
                int size = collectionRef.Count;
                bool moveOkay = (currentIndex + 1 < size) && (size == currentSize);
                if (moveOkay)
                {
                    currentIndex++;
                    currentObject = collectionRef[currentIndex];
                }
                else
                {
                    currentObject = null;
                }
                return moveOkay;
            }

            public void Reset()
            {
                currentIndex = -1;
                currentObject = null;
                if (collectionRef.Count != currentSize)
                {
                    throw new global::System.InvalidOperationException("Collection modified.");
                }
            }

            public void Dispose()
            {
                currentIndex = -1;
                currentObject = null;
            }
        }

        public void Clear()
        {
            HNAlgoNativePINVOKE.DoubleVector_Clear(swigCPtr);
        }

        public void Add(double x)
        {
            HNAlgoNativePINVOKE.DoubleVector_Add(swigCPtr, x);
        }

        private uint size()
        {
            uint ret = HNAlgoNativePINVOKE.DoubleVector_size(swigCPtr);
            return ret;
        }

        private uint capacity()
        {
            uint ret = HNAlgoNativePINVOKE.DoubleVector_capacity(swigCPtr);
            return ret;
        }

        private void reserve(uint n)
        {
            HNAlgoNativePINVOKE.DoubleVector_reserve(swigCPtr, n);
        }

        public DoubleVector() : this(HNAlgoNativePINVOKE.new_DoubleVector__SWIG_0(), true)
        {
        }

        public DoubleVector(DoubleVector other) : this(HNAlgoNativePINVOKE.new_DoubleVector__SWIG_1(DoubleVector.getCPtr(other)), true)
        {
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public DoubleVector(int capacity) : this(HNAlgoNativePINVOKE.new_DoubleVector__SWIG_2(capacity), true)
        {
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        private double getitemcopy(int index)
        {
            double ret = HNAlgoNativePINVOKE.DoubleVector_getitemcopy(swigCPtr, index);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        private double getitem(int index)
        {
            double ret = HNAlgoNativePINVOKE.DoubleVector_getitem(swigCPtr, index);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        private void setitem(int index, double val)
        {
            HNAlgoNativePINVOKE.DoubleVector_setitem(swigCPtr, index, val);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void AddRange(DoubleVector values)
        {
            HNAlgoNativePINVOKE.DoubleVector_AddRange(swigCPtr, DoubleVector.getCPtr(values));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public DoubleVector GetRange(int index, int count)
        {
            global::System.IntPtr cPtr = HNAlgoNativePINVOKE.DoubleVector_GetRange(swigCPtr, index, count);
            DoubleVector ret = (cPtr == global::System.IntPtr.Zero) ? null : new DoubleVector(cPtr, true);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        public void Insert(int index, double x)
        {
            HNAlgoNativePINVOKE.DoubleVector_Insert(swigCPtr, index, x);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void InsertRange(int index, DoubleVector values)
        {
            HNAlgoNativePINVOKE.DoubleVector_InsertRange(swigCPtr, index, DoubleVector.getCPtr(values));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void RemoveAt(int index)
        {
            HNAlgoNativePINVOKE.DoubleVector_RemoveAt(swigCPtr, index);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void RemoveRange(int index, int count)
        {
            HNAlgoNativePINVOKE.DoubleVector_RemoveRange(swigCPtr, index, count);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public static DoubleVector Repeat(double value, int count)
        {
            global::System.IntPtr cPtr = HNAlgoNativePINVOKE.DoubleVector_Repeat(value, count);
            DoubleVector ret = (cPtr == global::System.IntPtr.Zero) ? null : new DoubleVector(cPtr, true);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        public void Reverse()
        {
            HNAlgoNativePINVOKE.DoubleVector_Reverse__SWIG_0(swigCPtr);
        }

        public void Reverse(int index, int count)
        {
            HNAlgoNativePINVOKE.DoubleVector_Reverse__SWIG_1(swigCPtr, index, count);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void SetRange(int index, DoubleVector values)
        {
            HNAlgoNativePINVOKE.DoubleVector_SetRange(swigCPtr, index, DoubleVector.getCPtr(values));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public bool Contains(double value)
        {
            bool ret = HNAlgoNativePINVOKE.DoubleVector_Contains(swigCPtr, value);
            return ret;
        }

        public int IndexOf(double value)
        {
            int ret = HNAlgoNativePINVOKE.DoubleVector_IndexOf(swigCPtr, value);
            return ret;
        }

        public int LastIndexOf(double value)
        {
            int ret = HNAlgoNativePINVOKE.DoubleVector_LastIndexOf(swigCPtr, value);
            return ret;
        }

        public bool Remove(double value)
        {
            bool ret = HNAlgoNativePINVOKE.DoubleVector_Remove(swigCPtr, value);
            return ret;
        }

    }

}
namespace Huanan.Algorithm.DSP
{

    public class HeartBeatData : global::System.IDisposable, global::System.Collections.IEnumerable
        , global::System.Collections.Generic.IEnumerable<double>
    {
        private global::System.Runtime.InteropServices.HandleRef swigCPtr;
        protected bool swigCMemOwn;

        internal HeartBeatData(global::System.IntPtr cPtr, bool cMemoryOwn)
        {
            swigCMemOwn = cMemoryOwn;
            swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
        }

        internal static global::System.Runtime.InteropServices.HandleRef getCPtr(HeartBeatData obj)
        {
            return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
        }

        ~HeartBeatData()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            global::System.GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            lock (this)
            {
                if (swigCPtr.Handle != global::System.IntPtr.Zero)
                {
                    if (swigCMemOwn)
                    {
                        swigCMemOwn = false;
                        HNAlgoNativePINVOKE.delete_HeartBeatData(swigCPtr);
                    }
                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
                }
            }
        }

        public HeartBeatData(global::System.Collections.ICollection c) : this()
        {
            if (c == null)
                throw new global::System.ArgumentNullException("c");
            int end = global::System.Math.Min(this.Count, c.Count);
            int i = 0;
            foreach (double elem in c)
            {
                if (i >= end)
                    break;
                this[i++] = elem;
            }
        }

        public int Count
        {
            get
            {
                return (int)size();
            }
        }

        public double this[int index]
        {
            get
            {
                return getitem(index);
            }
            set
            {
                setitem(index, value);
            }
        }

        public bool IsEmpty
        {
            get
            {
                return empty();
            }
        }

        public void CopyTo(double[] array)
        {
            CopyTo(0, array, 0, this.Count);
        }

        public void CopyTo(double[] array, int arrayIndex)
        {
            CopyTo(0, array, arrayIndex, this.Count);
        }

        public void CopyTo(int index, double[] array, int arrayIndex, int count)
        {
            if (array == null)
                throw new global::System.ArgumentNullException("array");
            if (index < 0)
                throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero");
            if (arrayIndex < 0)
                throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
            if (count < 0)
                throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero");
            if (array.Rank > 1)
                throw new global::System.ArgumentException("Multi dimensional array.", "array");
            if (index + count > this.Count || arrayIndex + count > array.Length)
                throw new global::System.ArgumentException("Number of elements to copy is too large.");
            for (int i = 0; i < count; i++)
                array.SetValue(getitemcopy(index + i), arrayIndex + i);
        }

        global::System.Collections.Generic.IEnumerator<double> global::System.Collections.Generic.IEnumerable<double>.GetEnumerator()
        {
            return new HeartBeatDataEnumerator(this);
        }

        global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
        {
            return new HeartBeatDataEnumerator(this);
        }

        public HeartBeatDataEnumerator GetEnumerator()
        {
            return new HeartBeatDataEnumerator(this);
        }

        // Type-safe enumerator
        /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
        /// whenever the collection is modified. This has been done for changes in the size of the
        /// collection but not when one of the elements of the collection is modified as it is a bit
        /// tricky to detect unmanaged code that modifies the collection under our feet.
        public sealed class HeartBeatDataEnumerator : global::System.Collections.IEnumerator
          , global::System.Collections.Generic.IEnumerator<double>
        {
            private HeartBeatData collectionRef;
            private int currentIndex;
            private object currentObject;
            private int currentSize;

            public HeartBeatDataEnumerator(HeartBeatData collection)
            {
                collectionRef = collection;
                currentIndex = -1;
                currentObject = null;
                currentSize = collectionRef.Count;
            }

            // Type-safe iterator Current
            public double Current
            {
                get
                {
                    if (currentIndex == -1)
                        throw new global::System.InvalidOperationException("Enumeration not started.");
                    if (currentIndex > currentSize - 1)
                        throw new global::System.InvalidOperationException("Enumeration finished.");
                    if (currentObject == null)
                        throw new global::System.InvalidOperationException("Collection modified.");
                    return (double)currentObject;
                }
            }

            // Type-unsafe IEnumerator.Current
            object global::System.Collections.IEnumerator.Current
            {
                get
                {
                    return Current;
                }
            }

            public bool MoveNext()
            {
                int size = collectionRef.Count;
                bool moveOkay = (currentIndex + 1 < size) && (size == currentSize);
                if (moveOkay)
                {
                    currentIndex++;
                    currentObject = collectionRef[currentIndex];
                }
                else
                {
                    currentObject = null;
                }
                return moveOkay;
            }

            public void Reset()
            {
                currentIndex = -1;
                currentObject = null;
                if (collectionRef.Count != currentSize)
                {
                    throw new global::System.InvalidOperationException("Collection modified.");
                }
            }

            public void Dispose()
            {
                currentIndex = -1;
                currentObject = null;
            }
        }

        public HeartBeatData() : this(HNAlgoNativePINVOKE.new_HeartBeatData__SWIG_0(), true)
        {
        }

        public HeartBeatData(HeartBeatData other) : this(HNAlgoNativePINVOKE.new_HeartBeatData__SWIG_1(HeartBeatData.getCPtr(other)), true)
        {
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        private uint size()
        {
            uint ret = HNAlgoNativePINVOKE.HeartBeatData_size(swigCPtr);
            return ret;
        }

        private bool empty()
        {
            bool ret = HNAlgoNativePINVOKE.HeartBeatData_empty(swigCPtr);
            return ret;
        }

        public void Fill(double value)
        {
            HNAlgoNativePINVOKE.HeartBeatData_Fill(swigCPtr, value);
        }

        public void Swap(HeartBeatData other)
        {
            HNAlgoNativePINVOKE.HeartBeatData_Swap(swigCPtr, HeartBeatData.getCPtr(other));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        private double getitemcopy(int index)
        {
            double ret = HNAlgoNativePINVOKE.HeartBeatData_getitemcopy(swigCPtr, index);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        private double getitem(int index)
        {
            double ret = HNAlgoNativePINVOKE.HeartBeatData_getitem(swigCPtr, index);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        private void setitem(int index, double val)
        {
            HNAlgoNativePINVOKE.HeartBeatData_setitem(swigCPtr, index, val);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void Reverse()
        {
            HNAlgoNativePINVOKE.HeartBeatData_Reverse__SWIG_0(swigCPtr);
        }

        public void Reverse(int index, int count)
        {
            HNAlgoNativePINVOKE.HeartBeatData_Reverse__SWIG_1(swigCPtr, index, count);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

    }

}
namespace Huanan.Algorithm.DSP
{

    public class HeartBeatInfoVector : global::System.IDisposable, global::System.Collections.IEnumerable, global::System.Collections.Generic.IEnumerable<HeartBeatInfo>
    {
        private global::System.Runtime.InteropServices.HandleRef swigCPtr;
        protected bool swigCMemOwn;

        internal HeartBeatInfoVector(global::System.IntPtr cPtr, bool cMemoryOwn)
        {
            swigCMemOwn = cMemoryOwn;
            swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
        }

        internal static global::System.Runtime.InteropServices.HandleRef getCPtr(HeartBeatInfoVector obj)
        {
            return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
        }

        ~HeartBeatInfoVector()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            global::System.GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            lock (this)
            {
                if (swigCPtr.Handle != global::System.IntPtr.Zero)
                {
                    if (swigCMemOwn)
                    {
                        swigCMemOwn = false;
                        HNAlgoNativePINVOKE.delete_HeartBeatInfoVector(swigCPtr);
                    }
                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
                }
            }
        }

        public HeartBeatInfoVector(global::System.Collections.IEnumerable c) : this()
        {
            if (c == null)
                throw new global::System.ArgumentNullException("c");
            foreach (HeartBeatInfo element in c)
            {
                this.Add(element);
            }
        }

        public HeartBeatInfoVector(global::System.Collections.Generic.IEnumerable<HeartBeatInfo> c) : this()
        {
            if (c == null)
                throw new global::System.ArgumentNullException("c");
            foreach (HeartBeatInfo element in c)
            {
                this.Add(element);
            }
        }

        public bool IsFixedSize
        {
            get
            {
                return false;
            }
        }

        public bool IsReadOnly
        {
            get
            {
                return false;
            }
        }

        public HeartBeatInfo this[int index]
        {
            get
            {
                return getitem(index);
            }
            set
            {
                setitem(index, value);
            }
        }

        public int Capacity
        {
            get
            {
                return (int)capacity();
            }
            set
            {
                if (value < size())
                    throw new global::System.ArgumentOutOfRangeException("Capacity");
                reserve((uint)value);
            }
        }

        public int Count
        {
            get
            {
                return (int)size();
            }
        }

        public bool IsSynchronized
        {
            get
            {
                return false;
            }
        }

        public void CopyTo(HeartBeatInfo[] array)
        {
            CopyTo(0, array, 0, this.Count);
        }

        public void CopyTo(HeartBeatInfo[] array, int arrayIndex)
        {
            CopyTo(0, array, arrayIndex, this.Count);
        }

        public void CopyTo(int index, HeartBeatInfo[] array, int arrayIndex, int count)
        {
            if (array == null)
                throw new global::System.ArgumentNullException("array");
            if (index < 0)
                throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero");
            if (arrayIndex < 0)
                throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
            if (count < 0)
                throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero");
            if (array.Rank > 1)
                throw new global::System.ArgumentException("Multi dimensional array.", "array");
            if (index + count > this.Count || arrayIndex + count > array.Length)
                throw new global::System.ArgumentException("Number of elements to copy is too large.");
            for (int i = 0; i < count; i++)
                array.SetValue(getitemcopy(index + i), arrayIndex + i);
        }

        public HeartBeatInfo[] ToArray()
        {
            HeartBeatInfo[] array = new HeartBeatInfo[this.Count];
            this.CopyTo(array);
            return array;
        }

        global::System.Collections.Generic.IEnumerator<HeartBeatInfo> global::System.Collections.Generic.IEnumerable<HeartBeatInfo>.GetEnumerator()
        {
            return new HeartBeatInfoVectorEnumerator(this);
        }

        global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
        {
            return new HeartBeatInfoVectorEnumerator(this);
        }

        public HeartBeatInfoVectorEnumerator GetEnumerator()
        {
            return new HeartBeatInfoVectorEnumerator(this);
        }

        // Type-safe enumerator
        /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
        /// whenever the collection is modified. This has been done for changes in the size of the
        /// collection but not when one of the elements of the collection is modified as it is a bit
        /// tricky to detect unmanaged code that modifies the collection under our feet.
        public sealed class HeartBeatInfoVectorEnumerator : global::System.Collections.IEnumerator
          , global::System.Collections.Generic.IEnumerator<HeartBeatInfo>
        {
            private HeartBeatInfoVector collectionRef;
            private int currentIndex;
            private object currentObject;
            private int currentSize;

            public HeartBeatInfoVectorEnumerator(HeartBeatInfoVector collection)
            {
                collectionRef = collection;
                currentIndex = -1;
                currentObject = null;
                currentSize = collectionRef.Count;
            }

            // Type-safe iterator Current
            public HeartBeatInfo Current
            {
                get
                {
                    if (currentIndex == -1)
                        throw new global::System.InvalidOperationException("Enumeration not started.");
                    if (currentIndex > currentSize - 1)
                        throw new global::System.InvalidOperationException("Enumeration finished.");
                    if (currentObject == null)
                        throw new global::System.InvalidOperationException("Collection modified.");
                    return (HeartBeatInfo)currentObject;
                }
            }

            // Type-unsafe IEnumerator.Current
            object global::System.Collections.IEnumerator.Current
            {
                get
                {
                    return Current;
                }
            }

            public bool MoveNext()
            {
                int size = collectionRef.Count;
                bool moveOkay = (currentIndex + 1 < size) && (size == currentSize);
                if (moveOkay)
                {
                    currentIndex++;
                    currentObject = collectionRef[currentIndex];
                }
                else
                {
                    currentObject = null;
                }
                return moveOkay;
            }

            public void Reset()
            {
                currentIndex = -1;
                currentObject = null;
                if (collectionRef.Count != currentSize)
                {
                    throw new global::System.InvalidOperationException("Collection modified.");
                }
            }

            public void Dispose()
            {
                currentIndex = -1;
                currentObject = null;
            }
        }

        public void Clear()
        {
            HNAlgoNativePINVOKE.HeartBeatInfoVector_Clear(swigCPtr);
        }

        public void Add(HeartBeatInfo x)
        {
            HNAlgoNativePINVOKE.HeartBeatInfoVector_Add(swigCPtr, HeartBeatInfo.getCPtr(x));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        private uint size()
        {
            uint ret = HNAlgoNativePINVOKE.HeartBeatInfoVector_size(swigCPtr);
            return ret;
        }

        private uint capacity()
        {
            uint ret = HNAlgoNativePINVOKE.HeartBeatInfoVector_capacity(swigCPtr);
            return ret;
        }

        private void reserve(uint n)
        {
            HNAlgoNativePINVOKE.HeartBeatInfoVector_reserve(swigCPtr, n);
        }

        public HeartBeatInfoVector() : this(HNAlgoNativePINVOKE.new_HeartBeatInfoVector__SWIG_0(), true)
        {
        }

        public HeartBeatInfoVector(HeartBeatInfoVector other) : this(HNAlgoNativePINVOKE.new_HeartBeatInfoVector__SWIG_1(HeartBeatInfoVector.getCPtr(other)), true)
        {
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public HeartBeatInfoVector(int capacity) : this(HNAlgoNativePINVOKE.new_HeartBeatInfoVector__SWIG_2(capacity), true)
        {
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        private HeartBeatInfo getitemcopy(int index)
        {
            HeartBeatInfo ret = new HeartBeatInfo(HNAlgoNativePINVOKE.HeartBeatInfoVector_getitemcopy(swigCPtr, index), true);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        private HeartBeatInfo getitem(int index)
        {
            HeartBeatInfo ret = new HeartBeatInfo(HNAlgoNativePINVOKE.HeartBeatInfoVector_getitem(swigCPtr, index), false);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        private void setitem(int index, HeartBeatInfo val)
        {
            HNAlgoNativePINVOKE.HeartBeatInfoVector_setitem(swigCPtr, index, HeartBeatInfo.getCPtr(val));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void AddRange(HeartBeatInfoVector values)
        {
            HNAlgoNativePINVOKE.HeartBeatInfoVector_AddRange(swigCPtr, HeartBeatInfoVector.getCPtr(values));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public HeartBeatInfoVector GetRange(int index, int count)
        {
            global::System.IntPtr cPtr = HNAlgoNativePINVOKE.HeartBeatInfoVector_GetRange(swigCPtr, index, count);
            HeartBeatInfoVector ret = (cPtr == global::System.IntPtr.Zero) ? null : new HeartBeatInfoVector(cPtr, true);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        public void Insert(int index, HeartBeatInfo x)
        {
            HNAlgoNativePINVOKE.HeartBeatInfoVector_Insert(swigCPtr, index, HeartBeatInfo.getCPtr(x));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void InsertRange(int index, HeartBeatInfoVector values)
        {
            HNAlgoNativePINVOKE.HeartBeatInfoVector_InsertRange(swigCPtr, index, HeartBeatInfoVector.getCPtr(values));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void RemoveAt(int index)
        {
            HNAlgoNativePINVOKE.HeartBeatInfoVector_RemoveAt(swigCPtr, index);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void RemoveRange(int index, int count)
        {
            HNAlgoNativePINVOKE.HeartBeatInfoVector_RemoveRange(swigCPtr, index, count);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public static HeartBeatInfoVector Repeat(HeartBeatInfo value, int count)
        {
            global::System.IntPtr cPtr = HNAlgoNativePINVOKE.HeartBeatInfoVector_Repeat(HeartBeatInfo.getCPtr(value), count);
            HeartBeatInfoVector ret = (cPtr == global::System.IntPtr.Zero) ? null : new HeartBeatInfoVector(cPtr, true);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        public void Reverse()
        {
            HNAlgoNativePINVOKE.HeartBeatInfoVector_Reverse__SWIG_0(swigCPtr);
        }

        public void Reverse(int index, int count)
        {
            HNAlgoNativePINVOKE.HeartBeatInfoVector_Reverse__SWIG_1(swigCPtr, index, count);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void SetRange(int index, HeartBeatInfoVector values)
        {
            HNAlgoNativePINVOKE.HeartBeatInfoVector_SetRange(swigCPtr, index, HeartBeatInfoVector.getCPtr(values));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

    }

}
namespace Huanan.Algorithm.DSP
{

    public class HeartBeatInfo : global::System.IDisposable
    {
        private global::System.Runtime.InteropServices.HandleRef swigCPtr;
        protected bool swigCMemOwn;

        internal HeartBeatInfo(global::System.IntPtr cPtr, bool cMemoryOwn)
        {
            swigCMemOwn = cMemoryOwn;
            swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
        }

        internal static global::System.Runtime.InteropServices.HandleRef getCPtr(HeartBeatInfo obj)
        {
            return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
        }

        ~HeartBeatInfo()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            global::System.GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            lock (this)
            {
                if (swigCPtr.Handle != global::System.IntPtr.Zero)
                {
                    if (swigCMemOwn)
                    {
                        swigCMemOwn = false;
                        HNAlgoNativePINVOKE.delete_HeartBeatInfo(swigCPtr);
                    }
                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
                }
            }
        }

        public HeartBeatInfo() : this(HNAlgoNativePINVOKE.new_HeartBeatInfo(), true)
        {
        }

        public int ID
        {
            set
            {
                HNAlgoNativePINVOKE.HeartBeatInfo_ID_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.HeartBeatInfo_ID_get(swigCPtr);
                return ret;
            }
        }

        public int PBegin
        {
            set
            {
                HNAlgoNativePINVOKE.HeartBeatInfo_PBegin_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.HeartBeatInfo_PBegin_get(swigCPtr);
                return ret;
            }
        }

        public int PTop
        {
            set
            {
                HNAlgoNativePINVOKE.HeartBeatInfo_PTop_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.HeartBeatInfo_PTop_get(swigCPtr);
                return ret;
            }
        }

        public int PEnd
        {
            set
            {
                HNAlgoNativePINVOKE.HeartBeatInfo_PEnd_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.HeartBeatInfo_PEnd_get(swigCPtr);
                return ret;
            }
        }

        public int QRSBegin
        {
            set
            {
                HNAlgoNativePINVOKE.HeartBeatInfo_QRSBegin_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.HeartBeatInfo_QRSBegin_get(swigCPtr);
                return ret;
            }
        }

        public int QTop
        {
            set
            {
                HNAlgoNativePINVOKE.HeartBeatInfo_QTop_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.HeartBeatInfo_QTop_get(swigCPtr);
                return ret;
            }
        }

        public int QRSTop
        {
            set
            {
                HNAlgoNativePINVOKE.HeartBeatInfo_QRSTop_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.HeartBeatInfo_QRSTop_get(swigCPtr);
                return ret;
            }
        }

        public int STop
        {
            set
            {
                HNAlgoNativePINVOKE.HeartBeatInfo_STop_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.HeartBeatInfo_STop_get(swigCPtr);
                return ret;
            }
        }

        public int QRSEnd
        {
            set
            {
                HNAlgoNativePINVOKE.HeartBeatInfo_QRSEnd_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.HeartBeatInfo_QRSEnd_get(swigCPtr);
                return ret;
            }
        }

        public int TBegin
        {
            set
            {
                HNAlgoNativePINVOKE.HeartBeatInfo_TBegin_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.HeartBeatInfo_TBegin_get(swigCPtr);
                return ret;
            }
        }

        public int TTop
        {
            set
            {
                HNAlgoNativePINVOKE.HeartBeatInfo_TTop_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.HeartBeatInfo_TTop_get(swigCPtr);
                return ret;
            }
        }

        public int TEnd
        {
            set
            {
                HNAlgoNativePINVOKE.HeartBeatInfo_TEnd_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.HeartBeatInfo_TEnd_get(swigCPtr);
                return ret;
            }
        }

        public int UBegin
        {
            set
            {
                HNAlgoNativePINVOKE.HeartBeatInfo_UBegin_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.HeartBeatInfo_UBegin_get(swigCPtr);
                return ret;
            }
        }

        public int UEnd
        {
            set
            {
                HNAlgoNativePINVOKE.HeartBeatInfo_UEnd_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.HeartBeatInfo_UEnd_get(swigCPtr);
                return ret;
            }
        }

        public bool HasPSegment()
        {
            bool ret = HNAlgoNativePINVOKE.HeartBeatInfo_HasPSegment(swigCPtr);
            return ret;
        }

        public bool HasTSegment()
        {
            bool ret = HNAlgoNativePINVOKE.HeartBeatInfo_HasTSegment(swigCPtr);
            return ret;
        }

        public bool HasUSegment()
        {
            bool ret = HNAlgoNativePINVOKE.HeartBeatInfo_HasUSegment(swigCPtr);
            return ret;
        }

        public int Begin()
        {
            int ret = HNAlgoNativePINVOKE.HeartBeatInfo_Begin(swigCPtr);
            return ret;
        }

        public int End()
        {
            int ret = HNAlgoNativePINVOKE.HeartBeatInfo_End(swigCPtr);
            return ret;
        }

        public int GetPBegin()
        {
            int ret = HNAlgoNativePINVOKE.HeartBeatInfo_GetPBegin(swigCPtr);
            return ret;
        }

        public int GetPEnd()
        {
            int ret = HNAlgoNativePINVOKE.HeartBeatInfo_GetPEnd(swigCPtr);
            return ret;
        }

        public int GetTBegin()
        {
            int ret = HNAlgoNativePINVOKE.HeartBeatInfo_GetTBegin(swigCPtr);
            return ret;
        }

        public int GetTEnd()
        {
            int ret = HNAlgoNativePINVOKE.HeartBeatInfo_GetTEnd(swigCPtr);
            return ret;
        }

        public int GetUBegin()
        {
            int ret = HNAlgoNativePINVOKE.HeartBeatInfo_GetUBegin(swigCPtr);
            return ret;
        }

        public int GetUEnd()
        {
            int ret = HNAlgoNativePINVOKE.HeartBeatInfo_GetUEnd(swigCPtr);
            return ret;
        }

        public void Reset()
        {
            HNAlgoNativePINVOKE.HeartBeatInfo_Reset(swigCPtr);
        }

    }

}
namespace Huanan.Algorithm.DSP
{

    public class PaceBeatInfo : global::System.IDisposable
    {
        private global::System.Runtime.InteropServices.HandleRef swigCPtr;
        protected bool swigCMemOwn;

        internal PaceBeatInfo(global::System.IntPtr cPtr, bool cMemoryOwn)
        {
            swigCMemOwn = cMemoryOwn;
            swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
        }

        internal static global::System.Runtime.InteropServices.HandleRef getCPtr(PaceBeatInfo obj)
        {
            return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
        }

        ~PaceBeatInfo()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            global::System.GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            lock (this)
            {
                if (swigCPtr.Handle != global::System.IntPtr.Zero)
                {
                    if (swigCMemOwn)
                    {
                        swigCMemOwn = false;
                        HNAlgoNativePINVOKE.delete_PaceBeatInfo(swigCPtr);
                    }
                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
                }
            }
        }

        public int ID
        {
            set
            {
                HNAlgoNativePINVOKE.PaceBeatInfo_ID_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.PaceBeatInfo_ID_get(swigCPtr);
                return ret;
            }
        }

        public int pace
        {
            set
            {
                HNAlgoNativePINVOKE.PaceBeatInfo_pace_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.PaceBeatInfo_pace_get(swigCPtr);
                return ret;
            }
        }

        public int level
        {
            set
            {
                HNAlgoNativePINVOKE.PaceBeatInfo_level_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.PaceBeatInfo_level_get(swigCPtr);
                return ret;
            }
        }

        public PaceBeatInfo() : this(HNAlgoNativePINVOKE.new_PaceBeatInfo(), true)
        {
        }

    }

}
namespace Huanan.Algorithm.DSP
{

    public class ECGHeartBeatInfoVector : global::System.IDisposable, global::System.Collections.IEnumerable, global::System.Collections.Generic.IEnumerable<ECGHeartBeatInfo>
    {
        private global::System.Runtime.InteropServices.HandleRef swigCPtr;
        protected bool swigCMemOwn;

        internal ECGHeartBeatInfoVector(global::System.IntPtr cPtr, bool cMemoryOwn)
        {
            swigCMemOwn = cMemoryOwn;
            swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
        }

        internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ECGHeartBeatInfoVector obj)
        {
            return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
        }

        ~ECGHeartBeatInfoVector()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            global::System.GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            lock (this)
            {
                if (swigCPtr.Handle != global::System.IntPtr.Zero)
                {
                    if (swigCMemOwn)
                    {
                        swigCMemOwn = false;
                        HNAlgoNativePINVOKE.delete_ECGHeartBeatInfoVector(swigCPtr);
                    }
                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
                }
            }
        }

        public ECGHeartBeatInfoVector(global::System.Collections.IEnumerable c) : this()
        {
            if (c == null)
                throw new global::System.ArgumentNullException("c");
            foreach (ECGHeartBeatInfo element in c)
            {
                this.Add(element);
            }
        }

        public ECGHeartBeatInfoVector(global::System.Collections.Generic.IEnumerable<ECGHeartBeatInfo> c) : this()
        {
            if (c == null)
                throw new global::System.ArgumentNullException("c");
            foreach (ECGHeartBeatInfo element in c)
            {
                this.Add(element);
            }
        }

        public bool IsFixedSize
        {
            get
            {
                return false;
            }
        }

        public bool IsReadOnly
        {
            get
            {
                return false;
            }
        }

        public ECGHeartBeatInfo this[int index]
        {
            get
            {
                return getitem(index);
            }
            set
            {
                setitem(index, value);
            }
        }

        public int Capacity
        {
            get
            {
                return (int)capacity();
            }
            set
            {
                if (value < size())
                    throw new global::System.ArgumentOutOfRangeException("Capacity");
                reserve((uint)value);
            }
        }

        public int Count
        {
            get
            {
                return (int)size();
            }
        }

        public bool IsSynchronized
        {
            get
            {
                return false;
            }
        }

        public void CopyTo(ECGHeartBeatInfo[] array)
        {
            CopyTo(0, array, 0, this.Count);
        }

        public void CopyTo(ECGHeartBeatInfo[] array, int arrayIndex)
        {
            CopyTo(0, array, arrayIndex, this.Count);
        }

        public void CopyTo(int index, ECGHeartBeatInfo[] array, int arrayIndex, int count)
        {
            if (array == null)
                throw new global::System.ArgumentNullException("array");
            if (index < 0)
                throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero");
            if (arrayIndex < 0)
                throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
            if (count < 0)
                throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero");
            if (array.Rank > 1)
                throw new global::System.ArgumentException("Multi dimensional array.", "array");
            if (index + count > this.Count || arrayIndex + count > array.Length)
                throw new global::System.ArgumentException("Number of elements to copy is too large.");
            for (int i = 0; i < count; i++)
                array.SetValue(getitemcopy(index + i), arrayIndex + i);
        }

        public ECGHeartBeatInfo[] ToArray()
        {
            ECGHeartBeatInfo[] array = new ECGHeartBeatInfo[this.Count];
            this.CopyTo(array);
            return array;
        }

        global::System.Collections.Generic.IEnumerator<ECGHeartBeatInfo> global::System.Collections.Generic.IEnumerable<ECGHeartBeatInfo>.GetEnumerator()
        {
            return new ECGHeartBeatInfoVectorEnumerator(this);
        }

        global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
        {
            return new ECGHeartBeatInfoVectorEnumerator(this);
        }

        public ECGHeartBeatInfoVectorEnumerator GetEnumerator()
        {
            return new ECGHeartBeatInfoVectorEnumerator(this);
        }

        // Type-safe enumerator
        /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
        /// whenever the collection is modified. This has been done for changes in the size of the
        /// collection but not when one of the elements of the collection is modified as it is a bit
        /// tricky to detect unmanaged code that modifies the collection under our feet.
        public sealed class ECGHeartBeatInfoVectorEnumerator : global::System.Collections.IEnumerator
          , global::System.Collections.Generic.IEnumerator<ECGHeartBeatInfo>
        {
            private ECGHeartBeatInfoVector collectionRef;
            private int currentIndex;
            private object currentObject;
            private int currentSize;

            public ECGHeartBeatInfoVectorEnumerator(ECGHeartBeatInfoVector collection)
            {
                collectionRef = collection;
                currentIndex = -1;
                currentObject = null;
                currentSize = collectionRef.Count;
            }

            // Type-safe iterator Current
            public ECGHeartBeatInfo Current
            {
                get
                {
                    if (currentIndex == -1)
                        throw new global::System.InvalidOperationException("Enumeration not started.");
                    if (currentIndex > currentSize - 1)
                        throw new global::System.InvalidOperationException("Enumeration finished.");
                    if (currentObject == null)
                        throw new global::System.InvalidOperationException("Collection modified.");
                    return (ECGHeartBeatInfo)currentObject;
                }
            }

            // Type-unsafe IEnumerator.Current
            object global::System.Collections.IEnumerator.Current
            {
                get
                {
                    return Current;
                }
            }

            public bool MoveNext()
            {
                int size = collectionRef.Count;
                bool moveOkay = (currentIndex + 1 < size) && (size == currentSize);
                if (moveOkay)
                {
                    currentIndex++;
                    currentObject = collectionRef[currentIndex];
                }
                else
                {
                    currentObject = null;
                }
                return moveOkay;
            }

            public void Reset()
            {
                currentIndex = -1;
                currentObject = null;
                if (collectionRef.Count != currentSize)
                {
                    throw new global::System.InvalidOperationException("Collection modified.");
                }
            }

            public void Dispose()
            {
                currentIndex = -1;
                currentObject = null;
            }
        }

        public void Clear()
        {
            HNAlgoNativePINVOKE.ECGHeartBeatInfoVector_Clear(swigCPtr);
        }

        public void Add(ECGHeartBeatInfo x)
        {
            HNAlgoNativePINVOKE.ECGHeartBeatInfoVector_Add(swigCPtr, ECGHeartBeatInfo.getCPtr(x));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        private uint size()
        {
            uint ret = HNAlgoNativePINVOKE.ECGHeartBeatInfoVector_size(swigCPtr);
            return ret;
        }

        private uint capacity()
        {
            uint ret = HNAlgoNativePINVOKE.ECGHeartBeatInfoVector_capacity(swigCPtr);
            return ret;
        }

        private void reserve(uint n)
        {
            HNAlgoNativePINVOKE.ECGHeartBeatInfoVector_reserve(swigCPtr, n);
        }

        public ECGHeartBeatInfoVector() : this(HNAlgoNativePINVOKE.new_ECGHeartBeatInfoVector__SWIG_0(), true)
        {
        }

        public ECGHeartBeatInfoVector(ECGHeartBeatInfoVector other) : this(HNAlgoNativePINVOKE.new_ECGHeartBeatInfoVector__SWIG_1(ECGHeartBeatInfoVector.getCPtr(other)), true)
        {
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public ECGHeartBeatInfoVector(int capacity) : this(HNAlgoNativePINVOKE.new_ECGHeartBeatInfoVector__SWIG_2(capacity), true)
        {
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        private ECGHeartBeatInfo getitemcopy(int index)
        {
            ECGHeartBeatInfo ret = new ECGHeartBeatInfo(HNAlgoNativePINVOKE.ECGHeartBeatInfoVector_getitemcopy(swigCPtr, index), true);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        private ECGHeartBeatInfo getitem(int index)
        {
            ECGHeartBeatInfo ret = new ECGHeartBeatInfo(HNAlgoNativePINVOKE.ECGHeartBeatInfoVector_getitem(swigCPtr, index), false);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        private void setitem(int index, ECGHeartBeatInfo val)
        {
            HNAlgoNativePINVOKE.ECGHeartBeatInfoVector_setitem(swigCPtr, index, ECGHeartBeatInfo.getCPtr(val));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void AddRange(ECGHeartBeatInfoVector values)
        {
            HNAlgoNativePINVOKE.ECGHeartBeatInfoVector_AddRange(swigCPtr, ECGHeartBeatInfoVector.getCPtr(values));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public ECGHeartBeatInfoVector GetRange(int index, int count)
        {
            global::System.IntPtr cPtr = HNAlgoNativePINVOKE.ECGHeartBeatInfoVector_GetRange(swigCPtr, index, count);
            ECGHeartBeatInfoVector ret = (cPtr == global::System.IntPtr.Zero) ? null : new ECGHeartBeatInfoVector(cPtr, true);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        public void Insert(int index, ECGHeartBeatInfo x)
        {
            HNAlgoNativePINVOKE.ECGHeartBeatInfoVector_Insert(swigCPtr, index, ECGHeartBeatInfo.getCPtr(x));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void InsertRange(int index, ECGHeartBeatInfoVector values)
        {
            HNAlgoNativePINVOKE.ECGHeartBeatInfoVector_InsertRange(swigCPtr, index, ECGHeartBeatInfoVector.getCPtr(values));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void RemoveAt(int index)
        {
            HNAlgoNativePINVOKE.ECGHeartBeatInfoVector_RemoveAt(swigCPtr, index);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void RemoveRange(int index, int count)
        {
            HNAlgoNativePINVOKE.ECGHeartBeatInfoVector_RemoveRange(swigCPtr, index, count);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public static ECGHeartBeatInfoVector Repeat(ECGHeartBeatInfo value, int count)
        {
            global::System.IntPtr cPtr = HNAlgoNativePINVOKE.ECGHeartBeatInfoVector_Repeat(ECGHeartBeatInfo.getCPtr(value), count);
            ECGHeartBeatInfoVector ret = (cPtr == global::System.IntPtr.Zero) ? null : new ECGHeartBeatInfoVector(cPtr, true);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        public void Reverse()
        {
            HNAlgoNativePINVOKE.ECGHeartBeatInfoVector_Reverse__SWIG_0(swigCPtr);
        }

        public void Reverse(int index, int count)
        {
            HNAlgoNativePINVOKE.ECGHeartBeatInfoVector_Reverse__SWIG_1(swigCPtr, index, count);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void SetRange(int index, ECGHeartBeatInfoVector values)
        {
            HNAlgoNativePINVOKE.ECGHeartBeatInfoVector_SetRange(swigCPtr, index, ECGHeartBeatInfoVector.getCPtr(values));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

    }

}
namespace Huanan.Algorithm.DSP
{

    public class LeadParametersVector : global::System.IDisposable, global::System.Collections.IEnumerable, global::System.Collections.Generic.IEnumerable<LeadParameters>
    {
        private global::System.Runtime.InteropServices.HandleRef swigCPtr;
        protected bool swigCMemOwn;

        internal LeadParametersVector(global::System.IntPtr cPtr, bool cMemoryOwn)
        {
            swigCMemOwn = cMemoryOwn;
            swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
        }

        internal static global::System.Runtime.InteropServices.HandleRef getCPtr(LeadParametersVector obj)
        {
            return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
        }

        ~LeadParametersVector()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            global::System.GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            lock (this)
            {
                if (swigCPtr.Handle != global::System.IntPtr.Zero)
                {
                    if (swigCMemOwn)
                    {
                        swigCMemOwn = false;
                        HNAlgoNativePINVOKE.delete_LeadParametersVector(swigCPtr);
                    }
                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
                }
            }
        }

        public LeadParametersVector(global::System.Collections.IEnumerable c) : this()
        {
            if (c == null)
                throw new global::System.ArgumentNullException("c");
            foreach (LeadParameters element in c)
            {
                this.Add(element);
            }
        }

        public LeadParametersVector(global::System.Collections.Generic.IEnumerable<LeadParameters> c) : this()
        {
            if (c == null)
                throw new global::System.ArgumentNullException("c");
            foreach (LeadParameters element in c)
            {
                this.Add(element);
            }
        }

        public bool IsFixedSize
        {
            get
            {
                return false;
            }
        }

        public bool IsReadOnly
        {
            get
            {
                return false;
            }
        }

        public LeadParameters this[int index]
        {
            get
            {
                return getitem(index);
            }
            set
            {
                setitem(index, value);
            }
        }

        public int Capacity
        {
            get
            {
                return (int)capacity();
            }
            set
            {
                if (value < size())
                    throw new global::System.ArgumentOutOfRangeException("Capacity");
                reserve((uint)value);
            }
        }

        public int Count
        {
            get
            {
                return (int)size();
            }
        }

        public bool IsSynchronized
        {
            get
            {
                return false;
            }
        }

        public void CopyTo(LeadParameters[] array)
        {
            CopyTo(0, array, 0, this.Count);
        }

        public void CopyTo(LeadParameters[] array, int arrayIndex)
        {
            CopyTo(0, array, arrayIndex, this.Count);
        }

        public void CopyTo(int index, LeadParameters[] array, int arrayIndex, int count)
        {
            if (array == null)
                throw new global::System.ArgumentNullException("array");
            if (index < 0)
                throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero");
            if (arrayIndex < 0)
                throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
            if (count < 0)
                throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero");
            if (array.Rank > 1)
                throw new global::System.ArgumentException("Multi dimensional array.", "array");
            if (index + count > this.Count || arrayIndex + count > array.Length)
                throw new global::System.ArgumentException("Number of elements to copy is too large.");
            for (int i = 0; i < count; i++)
                array.SetValue(getitemcopy(index + i), arrayIndex + i);
        }

        public LeadParameters[] ToArray()
        {
            LeadParameters[] array = new LeadParameters[this.Count];
            this.CopyTo(array);
            return array;
        }

        global::System.Collections.Generic.IEnumerator<LeadParameters> global::System.Collections.Generic.IEnumerable<LeadParameters>.GetEnumerator()
        {
            return new LeadParametersVectorEnumerator(this);
        }

        global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
        {
            return new LeadParametersVectorEnumerator(this);
        }

        public LeadParametersVectorEnumerator GetEnumerator()
        {
            return new LeadParametersVectorEnumerator(this);
        }

        // Type-safe enumerator
        /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
        /// whenever the collection is modified. This has been done for changes in the size of the
        /// collection but not when one of the elements of the collection is modified as it is a bit
        /// tricky to detect unmanaged code that modifies the collection under our feet.
        public sealed class LeadParametersVectorEnumerator : global::System.Collections.IEnumerator
          , global::System.Collections.Generic.IEnumerator<LeadParameters>
        {
            private LeadParametersVector collectionRef;
            private int currentIndex;
            private object currentObject;
            private int currentSize;

            public LeadParametersVectorEnumerator(LeadParametersVector collection)
            {
                collectionRef = collection;
                currentIndex = -1;
                currentObject = null;
                currentSize = collectionRef.Count;
            }

            // Type-safe iterator Current
            public LeadParameters Current
            {
                get
                {
                    if (currentIndex == -1)
                        throw new global::System.InvalidOperationException("Enumeration not started.");
                    if (currentIndex > currentSize - 1)
                        throw new global::System.InvalidOperationException("Enumeration finished.");
                    if (currentObject == null)
                        throw new global::System.InvalidOperationException("Collection modified.");
                    return (LeadParameters)currentObject;
                }
            }

            // Type-unsafe IEnumerator.Current
            object global::System.Collections.IEnumerator.Current
            {
                get
                {
                    return Current;
                }
            }

            public bool MoveNext()
            {
                int size = collectionRef.Count;
                bool moveOkay = (currentIndex + 1 < size) && (size == currentSize);
                if (moveOkay)
                {
                    currentIndex++;
                    currentObject = collectionRef[currentIndex];
                }
                else
                {
                    currentObject = null;
                }
                return moveOkay;
            }

            public void Reset()
            {
                currentIndex = -1;
                currentObject = null;
                if (collectionRef.Count != currentSize)
                {
                    throw new global::System.InvalidOperationException("Collection modified.");
                }
            }

            public void Dispose()
            {
                currentIndex = -1;
                currentObject = null;
            }
        }

        public void Clear()
        {
            HNAlgoNativePINVOKE.LeadParametersVector_Clear(swigCPtr);
        }

        public void Add(LeadParameters x)
        {
            HNAlgoNativePINVOKE.LeadParametersVector_Add(swigCPtr, LeadParameters.getCPtr(x));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        private uint size()
        {
            uint ret = HNAlgoNativePINVOKE.LeadParametersVector_size(swigCPtr);
            return ret;
        }

        private uint capacity()
        {
            uint ret = HNAlgoNativePINVOKE.LeadParametersVector_capacity(swigCPtr);
            return ret;
        }

        private void reserve(uint n)
        {
            HNAlgoNativePINVOKE.LeadParametersVector_reserve(swigCPtr, n);
        }

        public LeadParametersVector() : this(HNAlgoNativePINVOKE.new_LeadParametersVector__SWIG_0(), true)
        {
        }

        public LeadParametersVector(LeadParametersVector other) : this(HNAlgoNativePINVOKE.new_LeadParametersVector__SWIG_1(LeadParametersVector.getCPtr(other)), true)
        {
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public LeadParametersVector(int capacity) : this(HNAlgoNativePINVOKE.new_LeadParametersVector__SWIG_2(capacity), true)
        {
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        private LeadParameters getitemcopy(int index)
        {
            LeadParameters ret = new LeadParameters(HNAlgoNativePINVOKE.LeadParametersVector_getitemcopy(swigCPtr, index), true);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        private LeadParameters getitem(int index)
        {
            LeadParameters ret = new LeadParameters(HNAlgoNativePINVOKE.LeadParametersVector_getitem(swigCPtr, index), false);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        private void setitem(int index, LeadParameters val)
        {
            HNAlgoNativePINVOKE.LeadParametersVector_setitem(swigCPtr, index, LeadParameters.getCPtr(val));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void AddRange(LeadParametersVector values)
        {
            HNAlgoNativePINVOKE.LeadParametersVector_AddRange(swigCPtr, LeadParametersVector.getCPtr(values));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public LeadParametersVector GetRange(int index, int count)
        {
            global::System.IntPtr cPtr = HNAlgoNativePINVOKE.LeadParametersVector_GetRange(swigCPtr, index, count);
            LeadParametersVector ret = (cPtr == global::System.IntPtr.Zero) ? null : new LeadParametersVector(cPtr, true);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        public void Insert(int index, LeadParameters x)
        {
            HNAlgoNativePINVOKE.LeadParametersVector_Insert(swigCPtr, index, LeadParameters.getCPtr(x));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void InsertRange(int index, LeadParametersVector values)
        {
            HNAlgoNativePINVOKE.LeadParametersVector_InsertRange(swigCPtr, index, LeadParametersVector.getCPtr(values));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void RemoveAt(int index)
        {
            HNAlgoNativePINVOKE.LeadParametersVector_RemoveAt(swigCPtr, index);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void RemoveRange(int index, int count)
        {
            HNAlgoNativePINVOKE.LeadParametersVector_RemoveRange(swigCPtr, index, count);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public static LeadParametersVector Repeat(LeadParameters value, int count)
        {
            global::System.IntPtr cPtr = HNAlgoNativePINVOKE.LeadParametersVector_Repeat(LeadParameters.getCPtr(value), count);
            LeadParametersVector ret = (cPtr == global::System.IntPtr.Zero) ? null : new LeadParametersVector(cPtr, true);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        public void Reverse()
        {
            HNAlgoNativePINVOKE.LeadParametersVector_Reverse__SWIG_0(swigCPtr);
        }

        public void Reverse(int index, int count)
        {
            HNAlgoNativePINVOKE.LeadParametersVector_Reverse__SWIG_1(swigCPtr, index, count);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void SetRange(int index, LeadParametersVector values)
        {
            HNAlgoNativePINVOKE.LeadParametersVector_SetRange(swigCPtr, index, LeadParametersVector.getCPtr(values));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

    }

}
namespace Huanan.Algorithm.DSP
{

    public class ECGHeartBeatInfo : HeartBeatInfo
    {
        private global::System.Runtime.InteropServices.HandleRef swigCPtr;

        internal ECGHeartBeatInfo(global::System.IntPtr cPtr, bool cMemoryOwn) : base(HNAlgoNativePINVOKE.ECGHeartBeatInfo_SWIGUpcast(cPtr), cMemoryOwn)
        {
            swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
        }

        internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ECGHeartBeatInfo obj)
        {
            return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
        }

        protected override void Dispose(bool disposing)
        {
            lock (this)
            {
                if (swigCPtr.Handle != global::System.IntPtr.Zero)
                {
                    if (swigCMemOwn)
                    {
                        swigCMemOwn = false;
                        HNAlgoNativePINVOKE.delete_ECGHeartBeatInfo(swigCPtr);
                    }
                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
                }
                base.Dispose(disposing);
            }
        }

        public HeartBeatData Data
        {
            set
            {
                HNAlgoNativePINVOKE.ECGHeartBeatInfo_Data_set(swigCPtr, HeartBeatData.getCPtr(value));
            }
            get
            {
                global::System.IntPtr cPtr = HNAlgoNativePINVOKE.ECGHeartBeatInfo_Data_get(swigCPtr);
                HeartBeatData ret = (cPtr == global::System.IntPtr.Zero) ? null : new HeartBeatData(cPtr, false);
                return ret;
            }
        }

        public ECGHeartBeatInfo() : this(HNAlgoNativePINVOKE.new_ECGHeartBeatInfo(), true)
        {
        }

    }

}
namespace Huanan.Algorithm.DSP
{

    public class LeadParameters : global::System.IDisposable
    {
        private global::System.Runtime.InteropServices.HandleRef swigCPtr;
        protected bool swigCMemOwn;

        internal LeadParameters(global::System.IntPtr cPtr, bool cMemoryOwn)
        {
            swigCMemOwn = cMemoryOwn;
            swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
        }

        internal static global::System.Runtime.InteropServices.HandleRef getCPtr(LeadParameters obj)
        {
            return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
        }

        ~LeadParameters()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            global::System.GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            lock (this)
            {
                if (swigCPtr.Handle != global::System.IntPtr.Zero)
                {
                    if (swigCMemOwn)
                    {
                        swigCMemOwn = false;
                        HNAlgoNativePINVOKE.delete_LeadParameters(swigCPtr);
                    }
                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
                }
            }
        }

        public LeadParameters() : this(HNAlgoNativePINVOKE.new_LeadParameters(), true)
        {
        }

        public double PPositive
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_PPositive_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.LeadParameters_PPositive_get(swigCPtr);
                return ret;
            }
        }

        public double PNegative
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_PNegative_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.LeadParameters_PNegative_get(swigCPtr);
                return ret;
            }
        }

        public int PWidth
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_PWidth_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.LeadParameters_PWidth_get(swigCPtr);
                return ret;
            }
        }

        public double TPositive
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_TPositive_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.LeadParameters_TPositive_get(swigCPtr);
                return ret;
            }
        }

        public double TNegative
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_TNegative_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.LeadParameters_TNegative_get(swigCPtr);
                return ret;
            }
        }

        public double STj
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_STj_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.LeadParameters_STj_get(swigCPtr);
                return ret;
            }
        }

        public double ST20
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_ST20_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.LeadParameters_ST20_get(swigCPtr);
                return ret;
            }
        }

        public double ST40
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_ST40_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.LeadParameters_ST40_get(swigCPtr);
                return ret;
            }
        }

        public double ST60
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_ST60_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.LeadParameters_ST60_get(swigCPtr);
                return ret;
            }
        }

        public double ST80
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_ST80_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.LeadParameters_ST80_get(swigCPtr);
                return ret;
            }
        }

        public double Q
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_Q_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.LeadParameters_Q_get(swigCPtr);
                return ret;
            }
        }

        public int QWidth
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_QWidth_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.LeadParameters_QWidth_get(swigCPtr);
                return ret;
            }
        }

        public double R
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_R_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.LeadParameters_R_get(swigCPtr);
                return ret;
            }
        }

        public int RWidth
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_RWidth_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.LeadParameters_RWidth_get(swigCPtr);
                return ret;
            }
        }

        public double S
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_S_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.LeadParameters_S_get(swigCPtr);
                return ret;
            }
        }

        public int SWidth
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_SWidth_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.LeadParameters_SWidth_get(swigCPtr);
                return ret;
            }
        }

        public double RB
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_RB_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.LeadParameters_RB_get(swigCPtr);
                return ret;
            }
        }

        public int RBWidth
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_RBWidth_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.LeadParameters_RBWidth_get(swigCPtr);
                return ret;
            }
        }

        public double SB
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_SB_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.LeadParameters_SB_get(swigCPtr);
                return ret;
            }
        }

        public int SBWidth
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_SBWidth_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.LeadParameters_SBWidth_get(swigCPtr);
                return ret;
            }
        }

        public int QRSWidth
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_QRSWidth_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.LeadParameters_QRSWidth_get(swigCPtr);
                return ret;
            }
        }

        public string QrsStyle
        {
            set
            {
                HNAlgoNativePINVOKE.LeadParameters_QrsStyle_set(swigCPtr, value);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            }
            get
            {
                string ret = HNAlgoNativePINVOKE.LeadParameters_QrsStyle_get(swigCPtr);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
                return ret;
            }
        }

    }

}
namespace Huanan.Algorithm.DSP
{

    public class ECGParameters : global::System.IDisposable
    {
        private global::System.Runtime.InteropServices.HandleRef swigCPtr;
        protected bool swigCMemOwn;

        internal ECGParameters(global::System.IntPtr cPtr, bool cMemoryOwn)
        {
            swigCMemOwn = cMemoryOwn;
            swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
        }

        internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ECGParameters obj)
        {
            return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
        }

        ~ECGParameters()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            global::System.GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            lock (this)
            {
                if (swigCPtr.Handle != global::System.IntPtr.Zero)
                {
                    if (swigCMemOwn)
                    {
                        swigCMemOwn = false;
                        HNAlgoNativePINVOKE.delete_ECGParameters(swigCPtr);
                    }
                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
                }
            }
        }

        public ECGParameters() : this(HNAlgoNativePINVOKE.new_ECGParameters(), true)
        {
        }

        public int HeartRate
        {
            set
            {
                HNAlgoNativePINVOKE.ECGParameters_HeartRate_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.ECGParameters_HeartRate_get(swigCPtr);
                return ret;
            }
        }

        public int PAxis
        {
            set
            {
                HNAlgoNativePINVOKE.ECGParameters_PAxis_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.ECGParameters_PAxis_get(swigCPtr);
                return ret;
            }
        }

        public int QRSAxis
        {
            set
            {
                HNAlgoNativePINVOKE.ECGParameters_QRSAxis_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.ECGParameters_QRSAxis_get(swigCPtr);
                return ret;
            }
        }

        public int TAxis
        {
            set
            {
                HNAlgoNativePINVOKE.ECGParameters_TAxis_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.ECGParameters_TAxis_get(swigCPtr);
                return ret;
            }
        }

        public int PR
        {
            set
            {
                HNAlgoNativePINVOKE.ECGParameters_PR_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.ECGParameters_PR_get(swigCPtr);
                return ret;
            }
        }

        public int QT
        {
            set
            {
                HNAlgoNativePINVOKE.ECGParameters_QT_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.ECGParameters_QT_get(swigCPtr);
                return ret;
            }
        }

        public int QTc
        {
            set
            {
                HNAlgoNativePINVOKE.ECGParameters_QTc_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.ECGParameters_QTc_get(swigCPtr);
                return ret;
            }
        }

        public int PWidth
        {
            set
            {
                HNAlgoNativePINVOKE.ECGParameters_PWidth_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.ECGParameters_PWidth_get(swigCPtr);
                return ret;
            }
        }

        public int QrsWidth
        {
            set
            {
                HNAlgoNativePINVOKE.ECGParameters_QrsWidth_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.ECGParameters_QrsWidth_get(swigCPtr);
                return ret;
            }
        }

        public double RV5
        {
            set
            {
                HNAlgoNativePINVOKE.ECGParameters_RV5_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.ECGParameters_RV5_get(swigCPtr);
                return ret;
            }
        }

        public double SV1
        {
            set
            {
                HNAlgoNativePINVOKE.ECGParameters_SV1_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.ECGParameters_SV1_get(swigCPtr);
                return ret;
            }
        }

        public double RV5SV1
        {
            set
            {
                HNAlgoNativePINVOKE.ECGParameters_RV5SV1_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.ECGParameters_RV5SV1_get(swigCPtr);
                return ret;
            }
        }

    }

}
namespace Huanan.Algorithm.DSP
{

    public class QTdParameters : global::System.IDisposable
    {
        private global::System.Runtime.InteropServices.HandleRef swigCPtr;
        protected bool swigCMemOwn;

        internal QTdParameters(global::System.IntPtr cPtr, bool cMemoryOwn)
        {
            swigCMemOwn = cMemoryOwn;
            swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
        }

        internal static global::System.Runtime.InteropServices.HandleRef getCPtr(QTdParameters obj)
        {
            return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
        }

        ~QTdParameters()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            global::System.GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            lock (this)
            {
                if (swigCPtr.Handle != global::System.IntPtr.Zero)
                {
                    if (swigCMemOwn)
                    {
                        swigCMemOwn = false;
                        HNAlgoNativePINVOKE.delete_QTdParameters(swigCPtr);
                    }
                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
                }
            }
        }

        public QTdParameters() : this(HNAlgoNativePINVOKE.new_QTdParameters(), true)
        {
        }

        public double QTMean
        {
            set
            {
                HNAlgoNativePINVOKE.QTdParameters_QTMean_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.QTdParameters_QTMean_get(swigCPtr);
                return ret;
            }
        }

        public double QTcMean
        {
            set
            {
                HNAlgoNativePINVOKE.QTdParameters_QTcMean_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.QTdParameters_QTcMean_get(swigCPtr);
                return ret;
            }
        }

        public double QTVariance
        {
            set
            {
                HNAlgoNativePINVOKE.QTdParameters_QTVariance_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.QTdParameters_QTVariance_get(swigCPtr);
                return ret;
            }
        }

        public double QTcVariance
        {
            set
            {
                HNAlgoNativePINVOKE.QTdParameters_QTcVariance_set(swigCPtr, value);
            }
            get
            {
                double ret = HNAlgoNativePINVOKE.QTdParameters_QTcVariance_get(swigCPtr);
                return ret;
            }
        }

        public int QTMin
        {
            set
            {
                HNAlgoNativePINVOKE.QTdParameters_QTMin_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.QTdParameters_QTMin_get(swigCPtr);
                return ret;
            }
        }

        public int QTcMin
        {
            set
            {
                HNAlgoNativePINVOKE.QTdParameters_QTcMin_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.QTdParameters_QTcMin_get(swigCPtr);
                return ret;
            }
        }

        public int QTMinLead
        {
            set
            {
                HNAlgoNativePINVOKE.QTdParameters_QTMinLead_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.QTdParameters_QTMinLead_get(swigCPtr);
                return ret;
            }
        }

        public int QTMax
        {
            set
            {
                HNAlgoNativePINVOKE.QTdParameters_QTMax_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.QTdParameters_QTMax_get(swigCPtr);
                return ret;
            }
        }

        public int QTcMax
        {
            set
            {
                HNAlgoNativePINVOKE.QTdParameters_QTcMax_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.QTdParameters_QTcMax_get(swigCPtr);
                return ret;
            }
        }

        public int QTMaxLead
        {
            set
            {
                HNAlgoNativePINVOKE.QTdParameters_QTMaxLead_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.QTdParameters_QTMaxLead_get(swigCPtr);
                return ret;
            }
        }

        public int QTd
        {
            set
            {
                HNAlgoNativePINVOKE.QTdParameters_QTd_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.QTdParameters_QTd_get(swigCPtr);
                return ret;
            }
        }

        public int QTcd
        {
            set
            {
                HNAlgoNativePINVOKE.QTdParameters_QTcd_set(swigCPtr, value);
            }
            get
            {
                int ret = HNAlgoNativePINVOKE.QTdParameters_QTcd_get(swigCPtr);
                return ret;
            }
        }

    }

}
namespace Huanan.Algorithm.DSP
{

    public class PSD_SPAC : global::System.IDisposable
    {
        private global::System.Runtime.InteropServices.HandleRef swigCPtr;
        protected bool swigCMemOwn;

        internal PSD_SPAC(global::System.IntPtr cPtr, bool cMemoryOwn)
        {
            swigCMemOwn = cMemoryOwn;
            swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
        }

        internal static global::System.Runtime.InteropServices.HandleRef getCPtr(PSD_SPAC obj)
        {
            return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
        }

        ~PSD_SPAC()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            global::System.GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            lock (this)
            {
                if (swigCPtr.Handle != global::System.IntPtr.Zero)
                {
                    if (swigCMemOwn)
                    {
                        swigCMemOwn = false;
                        HNAlgoNativePINVOKE.delete_PSD_SPAC(swigCPtr);
                    }
                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
                }
            }
        }

        public string HALF
        {
            set
            {
                HNAlgoNativePINVOKE.PSD_SPAC_HALF_set(swigCPtr, value);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            }
            get
            {
                string ret = HNAlgoNativePINVOKE.PSD_SPAC_HALF_get(swigCPtr);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
                return ret;
            }
        }

        public string U
        {
            set
            {
                HNAlgoNativePINVOKE.PSD_SPAC_U_set(swigCPtr, value);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            }
            get
            {
                string ret = HNAlgoNativePINVOKE.PSD_SPAC_U_get(swigCPtr);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
                return ret;
            }
        }

        public string N
        {
            set
            {
                HNAlgoNativePINVOKE.PSD_SPAC_N_set(swigCPtr, value);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            }
            get
            {
                string ret = HNAlgoNativePINVOKE.PSD_SPAC_N_get(swigCPtr);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
                return ret;
            }
        }

        public string A
        {
            set
            {
                HNAlgoNativePINVOKE.PSD_SPAC_A_set(swigCPtr, value);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            }
            get
            {
                string ret = HNAlgoNativePINVOKE.PSD_SPAC_A_get(swigCPtr);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
                return ret;
            }
        }

        public string A5
        {
            set
            {
                HNAlgoNativePINVOKE.PSD_SPAC_A5_set(swigCPtr, value);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            }
            get
            {
                string ret = HNAlgoNativePINVOKE.PSD_SPAC_A5_get(swigCPtr);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
                return ret;
            }
        }

        public PSD_SPAC() : this(HNAlgoNativePINVOKE.new_PSD_SPAC(), true)
        {
        }

    }

}
namespace Huanan.Algorithm.DSP
{

    public class PSD_PIHAC : global::System.IDisposable
    {
        private global::System.Runtime.InteropServices.HandleRef swigCPtr;
        protected bool swigCMemOwn;

        internal PSD_PIHAC(global::System.IntPtr cPtr, bool cMemoryOwn)
        {
            swigCMemOwn = cMemoryOwn;
            swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
        }

        internal static global::System.Runtime.InteropServices.HandleRef getCPtr(PSD_PIHAC obj)
        {
            return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
        }

        ~PSD_PIHAC()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            global::System.GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            lock (this)
            {
                if (swigCPtr.Handle != global::System.IntPtr.Zero)
                {
                    if (swigCMemOwn)
                    {
                        swigCMemOwn = false;
                        HNAlgoNativePINVOKE.delete_PSD_PIHAC(swigCPtr);
                    }
                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
                }
            }
        }

        public string f
        {
            set
            {
                HNAlgoNativePINVOKE.PSD_PIHAC_f_set(swigCPtr, value);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            }
            get
            {
                string ret = HNAlgoNativePINVOKE.PSD_PIHAC_f_get(swigCPtr);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
                return ret;
            }
        }

        public string M
        {
            set
            {
                HNAlgoNativePINVOKE.PSD_PIHAC_M_set(swigCPtr, value);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            }
            get
            {
                string ret = HNAlgoNativePINVOKE.PSD_PIHAC_M_get(swigCPtr);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
                return ret;
            }
        }

        public string RSR
        {
            set
            {
                HNAlgoNativePINVOKE.PSD_PIHAC_RSR_set(swigCPtr, value);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            }
            get
            {
                string ret = HNAlgoNativePINVOKE.PSD_PIHAC_RSR_get(swigCPtr);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
                return ret;
            }
        }

        public string CSR
        {
            set
            {
                HNAlgoNativePINVOKE.PSD_PIHAC_CSR_set(swigCPtr, value);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            }
            get
            {
                string ret = HNAlgoNativePINVOKE.PSD_PIHAC_CSR_get(swigCPtr);
                if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
                return ret;
            }
        }

        public PSD_PIHAC() : this(HNAlgoNativePINVOKE.new_PSD_PIHAC(), true)
        {
        }

    }

}
namespace Huanan.Algorithm.DSP
{

    public class PaceBeatInfoVector : global::System.IDisposable, global::System.Collections.IEnumerable, global::System.Collections.Generic.IEnumerable<PaceBeatInfo>
    {
        private global::System.Runtime.InteropServices.HandleRef swigCPtr;
        protected bool swigCMemOwn;

        internal PaceBeatInfoVector(global::System.IntPtr cPtr, bool cMemoryOwn)
        {
            swigCMemOwn = cMemoryOwn;
            swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
        }

        internal static global::System.Runtime.InteropServices.HandleRef getCPtr(PaceBeatInfoVector obj)
        {
            return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
        }

        ~PaceBeatInfoVector()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            global::System.GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            lock (this)
            {
                if (swigCPtr.Handle != global::System.IntPtr.Zero)
                {
                    if (swigCMemOwn)
                    {
                        swigCMemOwn = false;
                        HNAlgoNativePINVOKE.delete_PaceBeatInfoVector(swigCPtr);
                    }
                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
                }
            }
        }

        public PaceBeatInfoVector(global::System.Collections.IEnumerable c) : this()
        {
            if (c == null)
                throw new global::System.ArgumentNullException("c");
            foreach (PaceBeatInfo element in c)
            {
                this.Add(element);
            }
        }

        public PaceBeatInfoVector(global::System.Collections.Generic.IEnumerable<PaceBeatInfo> c) : this()
        {
            if (c == null)
                throw new global::System.ArgumentNullException("c");
            foreach (PaceBeatInfo element in c)
            {
                this.Add(element);
            }
        }

        public bool IsFixedSize
        {
            get
            {
                return false;
            }
        }

        public bool IsReadOnly
        {
            get
            {
                return false;
            }
        }

        public PaceBeatInfo this[int index]
        {
            get
            {
                return getitem(index);
            }
            set
            {
                setitem(index, value);
            }
        }

        public int Capacity
        {
            get
            {
                return (int)capacity();
            }
            set
            {
                if (value < size())
                    throw new global::System.ArgumentOutOfRangeException("Capacity");
                reserve((uint)value);
            }
        }

        public int Count
        {
            get
            {
                return (int)size();
            }
        }

        public bool IsSynchronized
        {
            get
            {
                return false;
            }
        }

        public void CopyTo(PaceBeatInfo[] array)
        {
            CopyTo(0, array, 0, this.Count);
        }

        public void CopyTo(PaceBeatInfo[] array, int arrayIndex)
        {
            CopyTo(0, array, arrayIndex, this.Count);
        }

        public void CopyTo(int index, PaceBeatInfo[] array, int arrayIndex, int count)
        {
            if (array == null)
                throw new global::System.ArgumentNullException("array");
            if (index < 0)
                throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero");
            if (arrayIndex < 0)
                throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
            if (count < 0)
                throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero");
            if (array.Rank > 1)
                throw new global::System.ArgumentException("Multi dimensional array.", "array");
            if (index + count > this.Count || arrayIndex + count > array.Length)
                throw new global::System.ArgumentException("Number of elements to copy is too large.");
            for (int i = 0; i < count; i++)
                array.SetValue(getitemcopy(index + i), arrayIndex + i);
        }

        public PaceBeatInfo[] ToArray()
        {
            PaceBeatInfo[] array = new PaceBeatInfo[this.Count];
            this.CopyTo(array);
            return array;
        }

        global::System.Collections.Generic.IEnumerator<PaceBeatInfo> global::System.Collections.Generic.IEnumerable<PaceBeatInfo>.GetEnumerator()
        {
            return new PaceBeatInfoVectorEnumerator(this);
        }

        global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
        {
            return new PaceBeatInfoVectorEnumerator(this);
        }

        public PaceBeatInfoVectorEnumerator GetEnumerator()
        {
            return new PaceBeatInfoVectorEnumerator(this);
        }

        // Type-safe enumerator
        /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
        /// whenever the collection is modified. This has been done for changes in the size of the
        /// collection but not when one of the elements of the collection is modified as it is a bit
        /// tricky to detect unmanaged code that modifies the collection under our feet.
        public sealed class PaceBeatInfoVectorEnumerator : global::System.Collections.IEnumerator
          , global::System.Collections.Generic.IEnumerator<PaceBeatInfo>
        {
            private PaceBeatInfoVector collectionRef;
            private int currentIndex;
            private object currentObject;
            private int currentSize;

            public PaceBeatInfoVectorEnumerator(PaceBeatInfoVector collection)
            {
                collectionRef = collection;
                currentIndex = -1;
                currentObject = null;
                currentSize = collectionRef.Count;
            }

            // Type-safe iterator Current
            public PaceBeatInfo Current
            {
                get
                {
                    if (currentIndex == -1)
                        throw new global::System.InvalidOperationException("Enumeration not started.");
                    if (currentIndex > currentSize - 1)
                        throw new global::System.InvalidOperationException("Enumeration finished.");
                    if (currentObject == null)
                        throw new global::System.InvalidOperationException("Collection modified.");
                    return (PaceBeatInfo)currentObject;
                }
            }

            // Type-unsafe IEnumerator.Current
            object global::System.Collections.IEnumerator.Current
            {
                get
                {
                    return Current;
                }
            }

            public bool MoveNext()
            {
                int size = collectionRef.Count;
                bool moveOkay = (currentIndex + 1 < size) && (size == currentSize);
                if (moveOkay)
                {
                    currentIndex++;
                    currentObject = collectionRef[currentIndex];
                }
                else
                {
                    currentObject = null;
                }
                return moveOkay;
            }

            public void Reset()
            {
                currentIndex = -1;
                currentObject = null;
                if (collectionRef.Count != currentSize)
                {
                    throw new global::System.InvalidOperationException("Collection modified.");
                }
            }

            public void Dispose()
            {
                currentIndex = -1;
                currentObject = null;
            }
        }

        public void Clear()
        {
            HNAlgoNativePINVOKE.PaceBeatInfoVector_Clear(swigCPtr);
        }

        public void Add(PaceBeatInfo x)
        {
            HNAlgoNativePINVOKE.PaceBeatInfoVector_Add(swigCPtr, PaceBeatInfo.getCPtr(x));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        private uint size()
        {
            uint ret = HNAlgoNativePINVOKE.PaceBeatInfoVector_size(swigCPtr);
            return ret;
        }

        private uint capacity()
        {
            uint ret = HNAlgoNativePINVOKE.PaceBeatInfoVector_capacity(swigCPtr);
            return ret;
        }

        private void reserve(uint n)
        {
            HNAlgoNativePINVOKE.PaceBeatInfoVector_reserve(swigCPtr, n);
        }

        public PaceBeatInfoVector() : this(HNAlgoNativePINVOKE.new_PaceBeatInfoVector__SWIG_0(), true)
        {
        }

        public PaceBeatInfoVector(PaceBeatInfoVector other) : this(HNAlgoNativePINVOKE.new_PaceBeatInfoVector__SWIG_1(PaceBeatInfoVector.getCPtr(other)), true)
        {
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public PaceBeatInfoVector(int capacity) : this(HNAlgoNativePINVOKE.new_PaceBeatInfoVector__SWIG_2(capacity), true)
        {
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        private PaceBeatInfo getitemcopy(int index)
        {
            PaceBeatInfo ret = new PaceBeatInfo(HNAlgoNativePINVOKE.PaceBeatInfoVector_getitemcopy(swigCPtr, index), true);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        private PaceBeatInfo getitem(int index)
        {
            PaceBeatInfo ret = new PaceBeatInfo(HNAlgoNativePINVOKE.PaceBeatInfoVector_getitem(swigCPtr, index), false);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        private void setitem(int index, PaceBeatInfo val)
        {
            HNAlgoNativePINVOKE.PaceBeatInfoVector_setitem(swigCPtr, index, PaceBeatInfo.getCPtr(val));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void AddRange(PaceBeatInfoVector values)
        {
            HNAlgoNativePINVOKE.PaceBeatInfoVector_AddRange(swigCPtr, PaceBeatInfoVector.getCPtr(values));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public PaceBeatInfoVector GetRange(int index, int count)
        {
            global::System.IntPtr cPtr = HNAlgoNativePINVOKE.PaceBeatInfoVector_GetRange(swigCPtr, index, count);
            PaceBeatInfoVector ret = (cPtr == global::System.IntPtr.Zero) ? null : new PaceBeatInfoVector(cPtr, true);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        public void Insert(int index, PaceBeatInfo x)
        {
            HNAlgoNativePINVOKE.PaceBeatInfoVector_Insert(swigCPtr, index, PaceBeatInfo.getCPtr(x));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void InsertRange(int index, PaceBeatInfoVector values)
        {
            HNAlgoNativePINVOKE.PaceBeatInfoVector_InsertRange(swigCPtr, index, PaceBeatInfoVector.getCPtr(values));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void RemoveAt(int index)
        {
            HNAlgoNativePINVOKE.PaceBeatInfoVector_RemoveAt(swigCPtr, index);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void RemoveRange(int index, int count)
        {
            HNAlgoNativePINVOKE.PaceBeatInfoVector_RemoveRange(swigCPtr, index, count);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public static PaceBeatInfoVector Repeat(PaceBeatInfo value, int count)
        {
            global::System.IntPtr cPtr = HNAlgoNativePINVOKE.PaceBeatInfoVector_Repeat(PaceBeatInfo.getCPtr(value), count);
            PaceBeatInfoVector ret = (cPtr == global::System.IntPtr.Zero) ? null : new PaceBeatInfoVector(cPtr, true);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        public void Reverse()
        {
            HNAlgoNativePINVOKE.PaceBeatInfoVector_Reverse__SWIG_0(swigCPtr);
        }

        public void Reverse(int index, int count)
        {
            HNAlgoNativePINVOKE.PaceBeatInfoVector_Reverse__SWIG_1(swigCPtr, index, count);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public void SetRange(int index, PaceBeatInfoVector values)
        {
            HNAlgoNativePINVOKE.PaceBeatInfoVector_SetRange(swigCPtr, index, PaceBeatInfoVector.getCPtr(values));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

    }

}
namespace Huanan.Algorithm.DSP
{

    class HNAlgoNativePINVOKE
    {

        protected class SWIGExceptionHelper
        {

            public delegate void ExceptionDelegate(string message);
            public delegate void ExceptionArgumentDelegate(string message, string paramName);

            static ExceptionDelegate applicationDelegate = new ExceptionDelegate(SetPendingApplicationException);
            static ExceptionDelegate arithmeticDelegate = new ExceptionDelegate(SetPendingArithmeticException);
            static ExceptionDelegate divideByZeroDelegate = new ExceptionDelegate(SetPendingDivideByZeroException);
            static ExceptionDelegate indexOutOfRangeDelegate = new ExceptionDelegate(SetPendingIndexOutOfRangeException);
            static ExceptionDelegate invalidCastDelegate = new ExceptionDelegate(SetPendingInvalidCastException);
            static ExceptionDelegate invalidOperationDelegate = new ExceptionDelegate(SetPendingInvalidOperationException);
            static ExceptionDelegate ioDelegate = new ExceptionDelegate(SetPendingIOException);
            static ExceptionDelegate nullReferenceDelegate = new ExceptionDelegate(SetPendingNullReferenceException);
            static ExceptionDelegate outOfMemoryDelegate = new ExceptionDelegate(SetPendingOutOfMemoryException);
            static ExceptionDelegate overflowDelegate = new ExceptionDelegate(SetPendingOverflowException);
            static ExceptionDelegate systemDelegate = new ExceptionDelegate(SetPendingSystemException);

            static ExceptionArgumentDelegate argumentDelegate = new ExceptionArgumentDelegate(SetPendingArgumentException);
            static ExceptionArgumentDelegate argumentNullDelegate = new ExceptionArgumentDelegate(SetPendingArgumentNullException);
            static ExceptionArgumentDelegate argumentOutOfRangeDelegate = new ExceptionArgumentDelegate(SetPendingArgumentOutOfRangeException);

            [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "SWIGRegisterExceptionCallbacks_HNAlgoNative")]
            public static extern void SWIGRegisterExceptionCallbacks_HNAlgoNative(
                                        ExceptionDelegate applicationDelegate,
                                        ExceptionDelegate arithmeticDelegate,
                                        ExceptionDelegate divideByZeroDelegate,
                                        ExceptionDelegate indexOutOfRangeDelegate,
                                        ExceptionDelegate invalidCastDelegate,
                                        ExceptionDelegate invalidOperationDelegate,
                                        ExceptionDelegate ioDelegate,
                                        ExceptionDelegate nullReferenceDelegate,
                                        ExceptionDelegate outOfMemoryDelegate,
                                        ExceptionDelegate overflowDelegate,
                                        ExceptionDelegate systemExceptionDelegate);

            [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "SWIGRegisterExceptionArgumentCallbacks_HNAlgoNative")]
            public static extern void SWIGRegisterExceptionCallbacksArgument_HNAlgoNative(
                                        ExceptionArgumentDelegate argumentDelegate,
                                        ExceptionArgumentDelegate argumentNullDelegate,
                                        ExceptionArgumentDelegate argumentOutOfRangeDelegate);

            static void SetPendingApplicationException(string message)
            {
                SWIGPendingException.Set(new global::System.ApplicationException(message, SWIGPendingException.Retrieve()));
            }
            static void SetPendingArithmeticException(string message)
            {
                SWIGPendingException.Set(new global::System.ArithmeticException(message, SWIGPendingException.Retrieve()));
            }
            static void SetPendingDivideByZeroException(string message)
            {
                SWIGPendingException.Set(new global::System.DivideByZeroException(message, SWIGPendingException.Retrieve()));
            }
            static void SetPendingIndexOutOfRangeException(string message)
            {
                SWIGPendingException.Set(new global::System.IndexOutOfRangeException(message, SWIGPendingException.Retrieve()));
            }
            static void SetPendingInvalidCastException(string message)
            {
                SWIGPendingException.Set(new global::System.InvalidCastException(message, SWIGPendingException.Retrieve()));
            }
            static void SetPendingInvalidOperationException(string message)
            {
                SWIGPendingException.Set(new global::System.InvalidOperationException(message, SWIGPendingException.Retrieve()));
            }
            static void SetPendingIOException(string message)
            {
                SWIGPendingException.Set(new global::System.IO.IOException(message, SWIGPendingException.Retrieve()));
            }
            static void SetPendingNullReferenceException(string message)
            {
                SWIGPendingException.Set(new global::System.NullReferenceException(message, SWIGPendingException.Retrieve()));
            }
            static void SetPendingOutOfMemoryException(string message)
            {
                SWIGPendingException.Set(new global::System.OutOfMemoryException(message, SWIGPendingException.Retrieve()));
            }
            static void SetPendingOverflowException(string message)
            {
                SWIGPendingException.Set(new global::System.OverflowException(message, SWIGPendingException.Retrieve()));
            }
            static void SetPendingSystemException(string message)
            {
                SWIGPendingException.Set(new global::System.SystemException(message, SWIGPendingException.Retrieve()));
            }

            static void SetPendingArgumentException(string message, string paramName)
            {
                SWIGPendingException.Set(new global::System.ArgumentException(message, paramName, SWIGPendingException.Retrieve()));
            }
            static void SetPendingArgumentNullException(string message, string paramName)
            {
                global::System.Exception e = SWIGPendingException.Retrieve();
                if (e != null) message = message + " Inner Exception: " + e.Message;
                SWIGPendingException.Set(new global::System.ArgumentNullException(paramName, message));
            }
            static void SetPendingArgumentOutOfRangeException(string message, string paramName)
            {
                global::System.Exception e = SWIGPendingException.Retrieve();
                if (e != null) message = message + " Inner Exception: " + e.Message;
                SWIGPendingException.Set(new global::System.ArgumentOutOfRangeException(paramName, message));
            }

            static SWIGExceptionHelper()
            {
                SWIGRegisterExceptionCallbacks_HNAlgoNative(
                                          applicationDelegate,
                                          arithmeticDelegate,
                                          divideByZeroDelegate,
                                          indexOutOfRangeDelegate,
                                          invalidCastDelegate,
                                          invalidOperationDelegate,
                                          ioDelegate,
                                          nullReferenceDelegate,
                                          outOfMemoryDelegate,
                                          overflowDelegate,
                                          systemDelegate);

                SWIGRegisterExceptionCallbacksArgument_HNAlgoNative(
                                          argumentDelegate,
                                          argumentNullDelegate,
                                          argumentOutOfRangeDelegate);
            }
        }

        protected static SWIGExceptionHelper swigExceptionHelper = new SWIGExceptionHelper();

        public class SWIGPendingException
        {
            [global::System.ThreadStatic]
            private static global::System.Exception pendingException = null;
            private static int numExceptionsPending = 0;
            private static global::System.Object exceptionsLock = null;

            public static bool Pending
            {
                get
                {
                    bool pending = false;
                    if (numExceptionsPending > 0)
                        if (pendingException != null)
                            pending = true;
                    return pending;
                }
            }

            public static void Set(global::System.Exception e)
            {
                if (pendingException != null)
                    throw new global::System.ApplicationException("FATAL: An earlier pending exception from unmanaged code was missed and thus not thrown (" + pendingException.ToString() + ")", e);
                pendingException = e;
                lock (exceptionsLock)
                {
                    numExceptionsPending++;
                }
            }

            public static global::System.Exception Retrieve()
            {
                global::System.Exception e = null;
                if (numExceptionsPending > 0)
                {
                    if (pendingException != null)
                    {
                        e = pendingException;
                        pendingException = null;
                        lock (exceptionsLock)
                        {
                            numExceptionsPending--;
                        }
                    }
                }
                return e;
            }

            static SWIGPendingException()
            {
                exceptionsLock = new global::System.Object();
            }
        }


        protected class SWIGStringHelper
        {

            public delegate string SWIGStringDelegate(string message);
            static SWIGStringDelegate stringDelegate = new SWIGStringDelegate(CreateString);

            [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "SWIGRegisterStringCallback_HNAlgoNative")]
            public static extern void SWIGRegisterStringCallback_HNAlgoNative(SWIGStringDelegate stringDelegate);

            static string CreateString(string cString)
            {
                return cString;
            }

            static SWIGStringHelper()
            {
                SWIGRegisterStringCallback_HNAlgoNative(stringDelegate);
            }
        }

        static protected SWIGStringHelper swigStringHelper = new SWIGStringHelper();


        static HNAlgoNativePINVOKE()
        {
        }


        protected class SWIGWStringHelper
        {

            [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]
            public delegate string SWIGWStringDelegate(global::System.IntPtr message);
            static SWIGWStringDelegate wstringDelegate = new SWIGWStringDelegate(CreateWString);

            [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "SWIGRegisterWStringCallback_HNAlgoNative")]
            public static extern void SWIGRegisterWStringCallback_HNAlgoNative(SWIGWStringDelegate wstringDelegate);

            static string CreateWString([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)] global::System.IntPtr cString)
            {
                return global::System.Runtime.InteropServices.Marshal.PtrToStringUni(cString);
            }

            static SWIGWStringHelper()
            {
                SWIGRegisterWStringCallback_HNAlgoNative(wstringDelegate);
            }
        }

        static protected SWIGWStringHelper swigWStringHelper = new SWIGWStringHelper();


        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_Clear___")]
        public static extern void IntVector_Clear(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_Add___")]
        public static extern void IntVector_Add(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_size___")]
        public static extern uint IntVector_size(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_capacity___")]
        public static extern uint IntVector_capacity(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_reserve___")]
        public static extern void IntVector_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_IntVector__SWIG_0___")]
        public static extern global::System.IntPtr new_IntVector__SWIG_0();

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_IntVector__SWIG_1___")]
        public static extern global::System.IntPtr new_IntVector__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_IntVector__SWIG_2___")]
        public static extern global::System.IntPtr new_IntVector__SWIG_2(int jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_getitemcopy___")]
        public static extern int IntVector_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_getitem___")]
        public static extern int IntVector_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_setitem___")]
        public static extern void IntVector_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_AddRange___")]
        public static extern void IntVector_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_GetRange___")]
        public static extern global::System.IntPtr IntVector_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_Insert___")]
        public static extern void IntVector_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_InsertRange___")]
        public static extern void IntVector_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_RemoveAt___")]
        public static extern void IntVector_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_RemoveRange___")]
        public static extern void IntVector_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_Repeat___")]
        public static extern global::System.IntPtr IntVector_Repeat(int jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_Reverse__SWIG_0___")]
        public static extern void IntVector_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_Reverse__SWIG_1___")]
        public static extern void IntVector_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_SetRange___")]
        public static extern void IntVector_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_Contains___")]
        public static extern bool IntVector_Contains(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_IndexOf___")]
        public static extern int IntVector_IndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_LastIndexOf___")]
        public static extern int IntVector_LastIndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_IntVector_Remove___")]
        public static extern bool IntVector_Remove(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_delete_IntVector___")]
        public static extern void delete_IntVector(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_Clear___")]
        public static extern void DoubleVector_Clear(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_Add___")]
        public static extern void DoubleVector_Add(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_size___")]
        public static extern uint DoubleVector_size(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_capacity___")]
        public static extern uint DoubleVector_capacity(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_reserve___")]
        public static extern void DoubleVector_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_DoubleVector__SWIG_0___")]
        public static extern global::System.IntPtr new_DoubleVector__SWIG_0();

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_DoubleVector__SWIG_1___")]
        public static extern global::System.IntPtr new_DoubleVector__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_DoubleVector__SWIG_2___")]
        public static extern global::System.IntPtr new_DoubleVector__SWIG_2(int jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_getitemcopy___")]
        public static extern double DoubleVector_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_getitem___")]
        public static extern double DoubleVector_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_setitem___")]
        public static extern void DoubleVector_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, double jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_AddRange___")]
        public static extern void DoubleVector_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_GetRange___")]
        public static extern global::System.IntPtr DoubleVector_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_Insert___")]
        public static extern void DoubleVector_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, double jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_InsertRange___")]
        public static extern void DoubleVector_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_RemoveAt___")]
        public static extern void DoubleVector_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_RemoveRange___")]
        public static extern void DoubleVector_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_Repeat___")]
        public static extern global::System.IntPtr DoubleVector_Repeat(double jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_Reverse__SWIG_0___")]
        public static extern void DoubleVector_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_Reverse__SWIG_1___")]
        public static extern void DoubleVector_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_SetRange___")]
        public static extern void DoubleVector_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_Contains___")]
        public static extern bool DoubleVector_Contains(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_IndexOf___")]
        public static extern int DoubleVector_IndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_LastIndexOf___")]
        public static extern int DoubleVector_LastIndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DoubleVector_Remove___")]
        public static extern bool DoubleVector_Remove(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_delete_DoubleVector___")]
        public static extern void delete_DoubleVector(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_HeartBeatData__SWIG_0___")]
        public static extern global::System.IntPtr new_HeartBeatData__SWIG_0();

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_HeartBeatData__SWIG_1___")]
        public static extern global::System.IntPtr new_HeartBeatData__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatData_size___")]
        public static extern uint HeartBeatData_size(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatData_empty___")]
        public static extern bool HeartBeatData_empty(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatData_Fill___")]
        public static extern void HeartBeatData_Fill(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatData_Swap___")]
        public static extern void HeartBeatData_Swap(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatData_getitemcopy___")]
        public static extern double HeartBeatData_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatData_getitem___")]
        public static extern double HeartBeatData_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatData_setitem___")]
        public static extern void HeartBeatData_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, double jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatData_Reverse__SWIG_0___")]
        public static extern void HeartBeatData_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatData_Reverse__SWIG_1___")]
        public static extern void HeartBeatData_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_delete_HeartBeatData___")]
        public static extern void delete_HeartBeatData(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfoVector_Clear___")]
        public static extern void HeartBeatInfoVector_Clear(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfoVector_Add___")]
        public static extern void HeartBeatInfoVector_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfoVector_size___")]
        public static extern uint HeartBeatInfoVector_size(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfoVector_capacity___")]
        public static extern uint HeartBeatInfoVector_capacity(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfoVector_reserve___")]
        public static extern void HeartBeatInfoVector_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_HeartBeatInfoVector__SWIG_0___")]
        public static extern global::System.IntPtr new_HeartBeatInfoVector__SWIG_0();

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_HeartBeatInfoVector__SWIG_1___")]
        public static extern global::System.IntPtr new_HeartBeatInfoVector__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_HeartBeatInfoVector__SWIG_2___")]
        public static extern global::System.IntPtr new_HeartBeatInfoVector__SWIG_2(int jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfoVector_getitemcopy___")]
        public static extern global::System.IntPtr HeartBeatInfoVector_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfoVector_getitem___")]
        public static extern global::System.IntPtr HeartBeatInfoVector_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfoVector_setitem___")]
        public static extern void HeartBeatInfoVector_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfoVector_AddRange___")]
        public static extern void HeartBeatInfoVector_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfoVector_GetRange___")]
        public static extern global::System.IntPtr HeartBeatInfoVector_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfoVector_Insert___")]
        public static extern void HeartBeatInfoVector_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfoVector_InsertRange___")]
        public static extern void HeartBeatInfoVector_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfoVector_RemoveAt___")]
        public static extern void HeartBeatInfoVector_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfoVector_RemoveRange___")]
        public static extern void HeartBeatInfoVector_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfoVector_Repeat___")]
        public static extern global::System.IntPtr HeartBeatInfoVector_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfoVector_Reverse__SWIG_0___")]
        public static extern void HeartBeatInfoVector_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfoVector_Reverse__SWIG_1___")]
        public static extern void HeartBeatInfoVector_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfoVector_SetRange___")]
        public static extern void HeartBeatInfoVector_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_delete_HeartBeatInfoVector___")]
        public static extern void delete_HeartBeatInfoVector(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_HeartBeatInfo___")]
        public static extern global::System.IntPtr new_HeartBeatInfo();

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_ID_set___")]
        public static extern void HeartBeatInfo_ID_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_ID_get___")]
        public static extern int HeartBeatInfo_ID_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_PBegin_set___")]
        public static extern void HeartBeatInfo_PBegin_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_PBegin_get___")]
        public static extern int HeartBeatInfo_PBegin_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_PTop_set___")]
        public static extern void HeartBeatInfo_PTop_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_PTop_get___")]
        public static extern int HeartBeatInfo_PTop_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_PEnd_set___")]
        public static extern void HeartBeatInfo_PEnd_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_PEnd_get___")]
        public static extern int HeartBeatInfo_PEnd_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_QRSBegin_set___")]
        public static extern void HeartBeatInfo_QRSBegin_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_QRSBegin_get___")]
        public static extern int HeartBeatInfo_QRSBegin_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_QTop_set___")]
        public static extern void HeartBeatInfo_QTop_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_QTop_get___")]
        public static extern int HeartBeatInfo_QTop_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_QRSTop_set___")]
        public static extern void HeartBeatInfo_QRSTop_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_QRSTop_get___")]
        public static extern int HeartBeatInfo_QRSTop_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_STop_set___")]
        public static extern void HeartBeatInfo_STop_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_STop_get___")]
        public static extern int HeartBeatInfo_STop_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_QRSEnd_set___")]
        public static extern void HeartBeatInfo_QRSEnd_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_QRSEnd_get___")]
        public static extern int HeartBeatInfo_QRSEnd_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_TBegin_set___")]
        public static extern void HeartBeatInfo_TBegin_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_TBegin_get___")]
        public static extern int HeartBeatInfo_TBegin_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_TTop_set___")]
        public static extern void HeartBeatInfo_TTop_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_TTop_get___")]
        public static extern int HeartBeatInfo_TTop_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_TEnd_set___")]
        public static extern void HeartBeatInfo_TEnd_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_TEnd_get___")]
        public static extern int HeartBeatInfo_TEnd_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_UBegin_set___")]
        public static extern void HeartBeatInfo_UBegin_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_UBegin_get___")]
        public static extern int HeartBeatInfo_UBegin_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_UEnd_set___")]
        public static extern void HeartBeatInfo_UEnd_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_UEnd_get___")]
        public static extern int HeartBeatInfo_UEnd_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_HasPSegment___")]
        public static extern bool HeartBeatInfo_HasPSegment(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_HasTSegment___")]
        public static extern bool HeartBeatInfo_HasTSegment(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_HasUSegment___")]
        public static extern bool HeartBeatInfo_HasUSegment(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_Begin___")]
        public static extern int HeartBeatInfo_Begin(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_End___")]
        public static extern int HeartBeatInfo_End(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_GetPBegin___")]
        public static extern int HeartBeatInfo_GetPBegin(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_GetPEnd___")]
        public static extern int HeartBeatInfo_GetPEnd(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_GetTBegin___")]
        public static extern int HeartBeatInfo_GetTBegin(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_GetTEnd___")]
        public static extern int HeartBeatInfo_GetTEnd(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_GetUBegin___")]
        public static extern int HeartBeatInfo_GetUBegin(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_GetUEnd___")]
        public static extern int HeartBeatInfo_GetUEnd(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_HeartBeatInfo_Reset___")]
        public static extern void HeartBeatInfo_Reset(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_delete_HeartBeatInfo___")]
        public static extern void delete_HeartBeatInfo(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfo_ID_set___")]
        public static extern void PaceBeatInfo_ID_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfo_ID_get___")]
        public static extern int PaceBeatInfo_ID_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfo_pace_set___")]
        public static extern void PaceBeatInfo_pace_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfo_pace_get___")]
        public static extern int PaceBeatInfo_pace_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfo_level_set___")]
        public static extern void PaceBeatInfo_level_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfo_level_get___")]
        public static extern int PaceBeatInfo_level_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_PaceBeatInfo___")]
        public static extern global::System.IntPtr new_PaceBeatInfo();

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_delete_PaceBeatInfo___")]
        public static extern void delete_PaceBeatInfo(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_DeputyHeartBeatLength_get___")]
        public static extern int DeputyHeartBeatLength_get();

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfoVector_Clear___")]
        public static extern void ECGHeartBeatInfoVector_Clear(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfoVector_Add___")]
        public static extern void ECGHeartBeatInfoVector_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfoVector_size___")]
        public static extern uint ECGHeartBeatInfoVector_size(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfoVector_capacity___")]
        public static extern uint ECGHeartBeatInfoVector_capacity(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfoVector_reserve___")]
        public static extern void ECGHeartBeatInfoVector_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_ECGHeartBeatInfoVector__SWIG_0___")]
        public static extern global::System.IntPtr new_ECGHeartBeatInfoVector__SWIG_0();

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_ECGHeartBeatInfoVector__SWIG_1___")]
        public static extern global::System.IntPtr new_ECGHeartBeatInfoVector__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_ECGHeartBeatInfoVector__SWIG_2___")]
        public static extern global::System.IntPtr new_ECGHeartBeatInfoVector__SWIG_2(int jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfoVector_getitemcopy___")]
        public static extern global::System.IntPtr ECGHeartBeatInfoVector_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfoVector_getitem___")]
        public static extern global::System.IntPtr ECGHeartBeatInfoVector_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfoVector_setitem___")]
        public static extern void ECGHeartBeatInfoVector_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfoVector_AddRange___")]
        public static extern void ECGHeartBeatInfoVector_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfoVector_GetRange___")]
        public static extern global::System.IntPtr ECGHeartBeatInfoVector_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfoVector_Insert___")]
        public static extern void ECGHeartBeatInfoVector_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfoVector_InsertRange___")]
        public static extern void ECGHeartBeatInfoVector_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfoVector_RemoveAt___")]
        public static extern void ECGHeartBeatInfoVector_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfoVector_RemoveRange___")]
        public static extern void ECGHeartBeatInfoVector_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfoVector_Repeat___")]
        public static extern global::System.IntPtr ECGHeartBeatInfoVector_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfoVector_Reverse__SWIG_0___")]
        public static extern void ECGHeartBeatInfoVector_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfoVector_Reverse__SWIG_1___")]
        public static extern void ECGHeartBeatInfoVector_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfoVector_SetRange___")]
        public static extern void ECGHeartBeatInfoVector_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_delete_ECGHeartBeatInfoVector___")]
        public static extern void delete_ECGHeartBeatInfoVector(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParametersVector_Clear___")]
        public static extern void LeadParametersVector_Clear(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParametersVector_Add___")]
        public static extern void LeadParametersVector_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParametersVector_size___")]
        public static extern uint LeadParametersVector_size(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParametersVector_capacity___")]
        public static extern uint LeadParametersVector_capacity(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParametersVector_reserve___")]
        public static extern void LeadParametersVector_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_LeadParametersVector__SWIG_0___")]
        public static extern global::System.IntPtr new_LeadParametersVector__SWIG_0();

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_LeadParametersVector__SWIG_1___")]
        public static extern global::System.IntPtr new_LeadParametersVector__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_LeadParametersVector__SWIG_2___")]
        public static extern global::System.IntPtr new_LeadParametersVector__SWIG_2(int jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParametersVector_getitemcopy___")]
        public static extern global::System.IntPtr LeadParametersVector_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParametersVector_getitem___")]
        public static extern global::System.IntPtr LeadParametersVector_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParametersVector_setitem___")]
        public static extern void LeadParametersVector_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParametersVector_AddRange___")]
        public static extern void LeadParametersVector_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParametersVector_GetRange___")]
        public static extern global::System.IntPtr LeadParametersVector_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParametersVector_Insert___")]
        public static extern void LeadParametersVector_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParametersVector_InsertRange___")]
        public static extern void LeadParametersVector_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParametersVector_RemoveAt___")]
        public static extern void LeadParametersVector_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParametersVector_RemoveRange___")]
        public static extern void LeadParametersVector_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParametersVector_Repeat___")]
        public static extern global::System.IntPtr LeadParametersVector_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParametersVector_Reverse__SWIG_0___")]
        public static extern void LeadParametersVector_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParametersVector_Reverse__SWIG_1___")]
        public static extern void LeadParametersVector_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParametersVector_SetRange___")]
        public static extern void LeadParametersVector_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_delete_LeadParametersVector___")]
        public static extern void delete_LeadParametersVector(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfo_Data_set___")]
        public static extern void ECGHeartBeatInfo_Data_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfo_Data_get___")]
        public static extern global::System.IntPtr ECGHeartBeatInfo_Data_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_ECGHeartBeatInfo___")]
        public static extern global::System.IntPtr new_ECGHeartBeatInfo();

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_delete_ECGHeartBeatInfo___")]
        public static extern void delete_ECGHeartBeatInfo(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_LeadParameters___")]
        public static extern global::System.IntPtr new_LeadParameters();

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_PPositive_set___")]
        public static extern void LeadParameters_PPositive_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_PPositive_get___")]
        public static extern double LeadParameters_PPositive_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_PNegative_set___")]
        public static extern void LeadParameters_PNegative_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_PNegative_get___")]
        public static extern double LeadParameters_PNegative_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_PWidth_set___")]
        public static extern void LeadParameters_PWidth_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_PWidth_get___")]
        public static extern int LeadParameters_PWidth_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_TPositive_set___")]
        public static extern void LeadParameters_TPositive_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_TPositive_get___")]
        public static extern double LeadParameters_TPositive_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_TNegative_set___")]
        public static extern void LeadParameters_TNegative_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_TNegative_get___")]
        public static extern double LeadParameters_TNegative_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_STj_set___")]
        public static extern void LeadParameters_STj_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_STj_get___")]
        public static extern double LeadParameters_STj_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_ST20_set___")]
        public static extern void LeadParameters_ST20_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_ST20_get___")]
        public static extern double LeadParameters_ST20_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_ST40_set___")]
        public static extern void LeadParameters_ST40_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_ST40_get___")]
        public static extern double LeadParameters_ST40_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_ST60_set___")]
        public static extern void LeadParameters_ST60_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_ST60_get___")]
        public static extern double LeadParameters_ST60_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_ST80_set___")]
        public static extern void LeadParameters_ST80_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_ST80_get___")]
        public static extern double LeadParameters_ST80_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_Q_set___")]
        public static extern void LeadParameters_Q_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_Q_get___")]
        public static extern double LeadParameters_Q_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_QWidth_set___")]
        public static extern void LeadParameters_QWidth_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_QWidth_get___")]
        public static extern int LeadParameters_QWidth_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_R_set___")]
        public static extern void LeadParameters_R_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_R_get___")]
        public static extern double LeadParameters_R_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_RWidth_set___")]
        public static extern void LeadParameters_RWidth_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_RWidth_get___")]
        public static extern int LeadParameters_RWidth_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_S_set___")]
        public static extern void LeadParameters_S_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_S_get___")]
        public static extern double LeadParameters_S_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_SWidth_set___")]
        public static extern void LeadParameters_SWidth_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_SWidth_get___")]
        public static extern int LeadParameters_SWidth_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_RB_set___")]
        public static extern void LeadParameters_RB_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_RB_get___")]
        public static extern double LeadParameters_RB_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_RBWidth_set___")]
        public static extern void LeadParameters_RBWidth_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_RBWidth_get___")]
        public static extern int LeadParameters_RBWidth_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_SB_set___")]
        public static extern void LeadParameters_SB_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_SB_get___")]
        public static extern double LeadParameters_SB_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_SBWidth_set___")]
        public static extern void LeadParameters_SBWidth_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_SBWidth_get___")]
        public static extern int LeadParameters_SBWidth_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_QRSWidth_set___")]
        public static extern void LeadParameters_QRSWidth_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_QRSWidth_get___")]
        public static extern int LeadParameters_QRSWidth_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_QrsStyle_set___")]
        public static extern void LeadParameters_QrsStyle_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)] string jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_LeadParameters_QrsStyle_get___")]
        [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]
        public static extern string LeadParameters_QrsStyle_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_delete_LeadParameters___")]
        public static extern void delete_LeadParameters(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_ECGParameters___")]
        public static extern global::System.IntPtr new_ECGParameters();

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_HeartRate_set___")]
        public static extern void ECGParameters_HeartRate_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_HeartRate_get___")]
        public static extern int ECGParameters_HeartRate_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_PAxis_set___")]
        public static extern void ECGParameters_PAxis_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_PAxis_get___")]
        public static extern int ECGParameters_PAxis_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_QRSAxis_set___")]
        public static extern void ECGParameters_QRSAxis_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_QRSAxis_get___")]
        public static extern int ECGParameters_QRSAxis_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_TAxis_set___")]
        public static extern void ECGParameters_TAxis_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_TAxis_get___")]
        public static extern int ECGParameters_TAxis_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_PR_set___")]
        public static extern void ECGParameters_PR_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_PR_get___")]
        public static extern int ECGParameters_PR_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_QT_set___")]
        public static extern void ECGParameters_QT_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_QT_get___")]
        public static extern int ECGParameters_QT_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_QTc_set___")]
        public static extern void ECGParameters_QTc_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_QTc_get___")]
        public static extern int ECGParameters_QTc_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_PWidth_set___")]
        public static extern void ECGParameters_PWidth_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_PWidth_get___")]
        public static extern int ECGParameters_PWidth_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_QrsWidth_set___")]
        public static extern void ECGParameters_QrsWidth_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_QrsWidth_get___")]
        public static extern int ECGParameters_QrsWidth_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_RV5_set___")]
        public static extern void ECGParameters_RV5_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_RV5_get___")]
        public static extern double ECGParameters_RV5_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_SV1_set___")]
        public static extern void ECGParameters_SV1_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_SV1_get___")]
        public static extern double ECGParameters_SV1_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_RV5SV1_set___")]
        public static extern void ECGParameters_RV5SV1_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGParameters_RV5SV1_get___")]
        public static extern double ECGParameters_RV5SV1_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_delete_ECGParameters___")]
        public static extern void delete_ECGParameters(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_QTdParameters___")]
        public static extern global::System.IntPtr new_QTdParameters();

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTMean_set___")]
        public static extern void QTdParameters_QTMean_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTMean_get___")]
        public static extern double QTdParameters_QTMean_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTcMean_set___")]
        public static extern void QTdParameters_QTcMean_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTcMean_get___")]
        public static extern double QTdParameters_QTcMean_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTVariance_set___")]
        public static extern void QTdParameters_QTVariance_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTVariance_get___")]
        public static extern double QTdParameters_QTVariance_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTcVariance_set___")]
        public static extern void QTdParameters_QTcVariance_set(global::System.Runtime.InteropServices.HandleRef jarg1, double jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTcVariance_get___")]
        public static extern double QTdParameters_QTcVariance_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTMin_set___")]
        public static extern void QTdParameters_QTMin_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTMin_get___")]
        public static extern int QTdParameters_QTMin_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTcMin_set___")]
        public static extern void QTdParameters_QTcMin_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTcMin_get___")]
        public static extern int QTdParameters_QTcMin_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTMinLead_set___")]
        public static extern void QTdParameters_QTMinLead_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTMinLead_get___")]
        public static extern int QTdParameters_QTMinLead_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTMax_set___")]
        public static extern void QTdParameters_QTMax_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTMax_get___")]
        public static extern int QTdParameters_QTMax_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTcMax_set___")]
        public static extern void QTdParameters_QTcMax_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTcMax_get___")]
        public static extern int QTdParameters_QTcMax_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTMaxLead_set___")]
        public static extern void QTdParameters_QTMaxLead_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTMaxLead_get___")]
        public static extern int QTdParameters_QTMaxLead_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTd_set___")]
        public static extern void QTdParameters_QTd_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTd_get___")]
        public static extern int QTdParameters_QTd_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTcd_set___")]
        public static extern void QTdParameters_QTcd_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_QTdParameters_QTcd_get___")]
        public static extern int QTdParameters_QTcd_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_delete_QTdParameters___")]
        public static extern void delete_QTdParameters(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_GetECGHeartBeatInfoOfAllLeads___")]
        public static extern bool GetECGHeartBeatInfoOfAllLeads(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, int jarg3, int jarg4, global::System.IntPtr jarg5, global::System.IntPtr jarg6, global::System.IntPtr jarg7, global::System.IntPtr jarg8, global::System.IntPtr jarg9, global::System.IntPtr jarg10, global::System.IntPtr jarg11, global::System.IntPtr jarg12, global::System.IntPtr jarg13, global::System.IntPtr jarg14, global::System.IntPtr jarg15, global::System.IntPtr jarg16, global::System.IntPtr jarg17, global::System.IntPtr jarg18, global::System.IntPtr jarg19, global::System.IntPtr jarg20, global::System.IntPtr jarg21, global::System.IntPtr jarg22);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_GetSummaryHeartBeatInfo__SWIG_0___")]
        public static extern void GetSummaryHeartBeatInfo__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_GetSummaryHeartBeatInfo__SWIG_1___")]
        public static extern void GetSummaryHeartBeatInfo__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_GetECGHeartBeatParametersOfAllLeads___")]
        public static extern bool GetECGHeartBeatParametersOfAllLeads(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_GetECGParameters___")]
        public static extern bool GetECGParameters(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_GetQTdParameters___")]
        public static extern bool GetQTdParameters(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PER_FREGMENT_SIZE_get___")]
        public static extern int PER_FREGMENT_SIZE_get();

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_FCG_DATA_SIZE_get___")]
        public static extern int FCG_DATA_SIZE_get();

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PSD_SPAC_HALF_set___")]
        public static extern void PSD_SPAC_HALF_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)] string jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PSD_SPAC_HALF_get___")]
        [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]
        public static extern string PSD_SPAC_HALF_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PSD_SPAC_U_set___")]
        public static extern void PSD_SPAC_U_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)] string jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PSD_SPAC_U_get___")]
        [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]
        public static extern string PSD_SPAC_U_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PSD_SPAC_N_set___")]
        public static extern void PSD_SPAC_N_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)] string jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PSD_SPAC_N_get___")]
        [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]
        public static extern string PSD_SPAC_N_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PSD_SPAC_A_set___")]
        public static extern void PSD_SPAC_A_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)] string jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PSD_SPAC_A_get___")]
        [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]
        public static extern string PSD_SPAC_A_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PSD_SPAC_A5_set___")]
        public static extern void PSD_SPAC_A5_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)] string jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PSD_SPAC_A5_get___")]
        [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]
        public static extern string PSD_SPAC_A5_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_PSD_SPAC___")]
        public static extern global::System.IntPtr new_PSD_SPAC();

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_delete_PSD_SPAC___")]
        public static extern void delete_PSD_SPAC(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PSD_PIHAC_f_set___")]
        public static extern void PSD_PIHAC_f_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)] string jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PSD_PIHAC_f_get___")]
        [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]
        public static extern string PSD_PIHAC_f_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PSD_PIHAC_M_set___")]
        public static extern void PSD_PIHAC_M_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)] string jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PSD_PIHAC_M_get___")]
        [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]
        public static extern string PSD_PIHAC_M_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PSD_PIHAC_RSR_set___")]
        public static extern void PSD_PIHAC_RSR_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)] string jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PSD_PIHAC_RSR_get___")]
        [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]
        public static extern string PSD_PIHAC_RSR_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PSD_PIHAC_CSR_set___")]
        public static extern void PSD_PIHAC_CSR_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)] string jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PSD_PIHAC_CSR_get___")]
        [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)]
        public static extern string PSD_PIHAC_CSR_get(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_PSD_PIHAC___")]
        public static extern global::System.IntPtr new_PSD_PIHAC();

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_delete_PSD_PIHAC___")]
        public static extern void delete_PSD_PIHAC(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_Spectrum2Analyse___")]
        public static extern void Spectrum2Analyse(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.IntPtr jarg2, global::System.IntPtr jarg3, int jarg4, global::System.IntPtr jarg5, global::System.IntPtr jarg6, global::System.IntPtr jarg7, global::System.IntPtr jarg8, global::System.Runtime.InteropServices.HandleRef jarg9, global::System.Runtime.InteropServices.HandleRef jarg10, global::System.Runtime.InteropServices.HandleRef jarg11, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.LPWStr)] string jarg12);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_CalculateSingleLeadGxx___")]
        public static extern void CalculateSingleLeadGxx(global::System.IntPtr jarg1, int jarg2, global::System.IntPtr jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_FindAllHeartBeats___")]
        public static extern uint FindAllHeartBeats(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3, global::System.IntPtr jarg4, global::System.IntPtr jarg5, global::System.IntPtr jarg6, global::System.IntPtr jarg7, global::System.IntPtr jarg8, global::System.IntPtr jarg9, global::System.IntPtr jarg10, global::System.IntPtr jarg11, global::System.IntPtr jarg12, global::System.IntPtr jarg13, global::System.IntPtr jarg14, global::System.IntPtr jarg15, global::System.IntPtr jarg16, global::System.IntPtr jarg17, global::System.IntPtr jarg18, global::System.IntPtr jarg19, global::System.IntPtr jarg20, global::System.IntPtr jarg21);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfoVector_Clear___")]
        public static extern void PaceBeatInfoVector_Clear(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfoVector_Add___")]
        public static extern void PaceBeatInfoVector_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfoVector_size___")]
        public static extern uint PaceBeatInfoVector_size(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfoVector_capacity___")]
        public static extern uint PaceBeatInfoVector_capacity(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfoVector_reserve___")]
        public static extern void PaceBeatInfoVector_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_PaceBeatInfoVector__SWIG_0___")]
        public static extern global::System.IntPtr new_PaceBeatInfoVector__SWIG_0();

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_PaceBeatInfoVector__SWIG_1___")]
        public static extern global::System.IntPtr new_PaceBeatInfoVector__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_new_PaceBeatInfoVector__SWIG_2___")]
        public static extern global::System.IntPtr new_PaceBeatInfoVector__SWIG_2(int jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfoVector_getitemcopy___")]
        public static extern global::System.IntPtr PaceBeatInfoVector_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfoVector_getitem___")]
        public static extern global::System.IntPtr PaceBeatInfoVector_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfoVector_setitem___")]
        public static extern void PaceBeatInfoVector_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfoVector_AddRange___")]
        public static extern void PaceBeatInfoVector_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfoVector_GetRange___")]
        public static extern global::System.IntPtr PaceBeatInfoVector_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfoVector_Insert___")]
        public static extern void PaceBeatInfoVector_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfoVector_InsertRange___")]
        public static extern void PaceBeatInfoVector_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfoVector_RemoveAt___")]
        public static extern void PaceBeatInfoVector_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfoVector_RemoveRange___")]
        public static extern void PaceBeatInfoVector_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfoVector_Repeat___")]
        public static extern global::System.IntPtr PaceBeatInfoVector_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfoVector_Reverse__SWIG_0___")]
        public static extern void PaceBeatInfoVector_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfoVector_Reverse__SWIG_1___")]
        public static extern void PaceBeatInfoVector_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_PaceBeatInfoVector_SetRange___")]
        public static extern void PaceBeatInfoVector_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_delete_PaceBeatInfoVector___")]
        public static extern void delete_PaceBeatInfoVector(global::System.Runtime.InteropServices.HandleRef jarg1);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_GetPace__SWIG_0___")]
        public static extern uint GetPace__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.IntPtr jarg2, int jarg3, int jarg4, int jarg5, bool jarg6);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_GetPace__SWIG_1___")]
        public static extern uint GetPace__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.IntPtr jarg2, int jarg3, int jarg4, int jarg5);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_FindAllFrankHeartBeats___")]
        public static extern uint FindAllFrankHeartBeats(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2, global::System.IntPtr jarg3, global::System.IntPtr jarg4, global::System.IntPtr jarg5);

        [global::System.Runtime.InteropServices.DllImport("Huanan.Algorithm.DSP.Native.dll", EntryPoint = "CSharp_HuananfAlgorithmfDSP_ECGHeartBeatInfo_SWIGUpcast___")]
        public static extern global::System.IntPtr ECGHeartBeatInfo_SWIGUpcast(global::System.IntPtr jarg1);
    }

}
namespace Huanan.Algorithm.DSP
{

    public class HNAlgoNative
    {
        public static int DeputyHeartBeatLength
        {
            get
            {
                int ret = HNAlgoNativePINVOKE.DeputyHeartBeatLength_get();
                return ret;
            }
        }

        public unsafe static bool GetECGHeartBeatInfoOfAllLeads(ECGHeartBeatInfoVector hbiOfAllLeads, HeartBeatInfoVector hbiv, int heartBeatID, int dataLength, double[] lead0, double[] lead1, double[] lead2, double[] lead3, double[] lead4, double[] lead5, double[] lead6, double[] lead7, double[] lead8, double[] lead9, double[] lead10, double[] lead11, double[] lead12, double[] lead13, double[] lead14, double[] lead15, double[] lead16, double[] lead17)
        {
            fixed (double* swig_ptrTo_lead0 = lead0)
            {
                fixed (double* swig_ptrTo_lead1 = lead1)
                {
                    fixed (double* swig_ptrTo_lead2 = lead2)
                    {
                        fixed (double* swig_ptrTo_lead3 = lead3)
                        {
                            fixed (double* swig_ptrTo_lead4 = lead4)
                            {
                                fixed (double* swig_ptrTo_lead5 = lead5)
                                {
                                    fixed (double* swig_ptrTo_lead6 = lead6)
                                    {
                                        fixed (double* swig_ptrTo_lead7 = lead7)
                                        {
                                            fixed (double* swig_ptrTo_lead8 = lead8)
                                            {
                                                fixed (double* swig_ptrTo_lead9 = lead9)
                                                {
                                                    fixed (double* swig_ptrTo_lead10 = lead10)
                                                    {
                                                        fixed (double* swig_ptrTo_lead11 = lead11)
                                                        {
                                                            fixed (double* swig_ptrTo_lead12 = lead12)
                                                            {
                                                                fixed (double* swig_ptrTo_lead13 = lead13)
                                                                {
                                                                    fixed (double* swig_ptrTo_lead14 = lead14)
                                                                    {
                                                                        fixed (double* swig_ptrTo_lead15 = lead15)
                                                                        {
                                                                            fixed (double* swig_ptrTo_lead16 = lead16)
                                                                            {
                                                                                fixed (double* swig_ptrTo_lead17 = lead17)
                                                                                {
                                                                                    {
                                                                                        bool ret = HNAlgoNativePINVOKE.GetECGHeartBeatInfoOfAllLeads(ECGHeartBeatInfoVector.getCPtr(hbiOfAllLeads), HeartBeatInfoVector.getCPtr(hbiv), heartBeatID, dataLength, (global::System.IntPtr)swig_ptrTo_lead0, (global::System.IntPtr)swig_ptrTo_lead1, (global::System.IntPtr)swig_ptrTo_lead2, (global::System.IntPtr)swig_ptrTo_lead3, (global::System.IntPtr)swig_ptrTo_lead4, (global::System.IntPtr)swig_ptrTo_lead5, (global::System.IntPtr)swig_ptrTo_lead6, (global::System.IntPtr)swig_ptrTo_lead7, (global::System.IntPtr)swig_ptrTo_lead8, (global::System.IntPtr)swig_ptrTo_lead9, (global::System.IntPtr)swig_ptrTo_lead10, (global::System.IntPtr)swig_ptrTo_lead11, (global::System.IntPtr)swig_ptrTo_lead12, (global::System.IntPtr)swig_ptrTo_lead13, (global::System.IntPtr)swig_ptrTo_lead14, (global::System.IntPtr)swig_ptrTo_lead15, (global::System.IntPtr)swig_ptrTo_lead16, (global::System.IntPtr)swig_ptrTo_lead17);
                                                                                        if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
                                                                                        return ret;
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        public static void GetSummaryHeartBeatInfo(HeartBeatInfoVector hbiv, HeartBeatInfo hbi)
        {
            HNAlgoNativePINVOKE.GetSummaryHeartBeatInfo__SWIG_0(HeartBeatInfoVector.getCPtr(hbiv), HeartBeatInfo.getCPtr(hbi));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public static void GetSummaryHeartBeatInfo(ECGHeartBeatInfoVector ehbiv, HeartBeatInfo hbi)
        {
            HNAlgoNativePINVOKE.GetSummaryHeartBeatInfo__SWIG_1(ECGHeartBeatInfoVector.getCPtr(ehbiv), HeartBeatInfo.getCPtr(hbi));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
        }

        public static bool GetECGHeartBeatParametersOfAllLeads(LeadParametersVector allLeadsParams, ECGHeartBeatInfoVector hbiOfAllLeads)
        {
            bool ret = HNAlgoNativePINVOKE.GetECGHeartBeatParametersOfAllLeads(LeadParametersVector.getCPtr(allLeadsParams), ECGHeartBeatInfoVector.getCPtr(hbiOfAllLeads));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        public static bool GetECGParameters(ECGParameters ecgParams, HeartBeatInfoVector hbiv, ECGHeartBeatInfoVector hbiOfAllLeads)
        {
            bool ret = HNAlgoNativePINVOKE.GetECGParameters(ECGParameters.getCPtr(ecgParams), HeartBeatInfoVector.getCPtr(hbiv), ECGHeartBeatInfoVector.getCPtr(hbiOfAllLeads));
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        public static bool GetQTdParameters(QTdParameters QTd, ECGHeartBeatInfoVector hbiOfAllLeads, int heartRate)
        {
            bool ret = HNAlgoNativePINVOKE.GetQTdParameters(QTdParameters.getCPtr(QTd), ECGHeartBeatInfoVector.getCPtr(hbiOfAllLeads), heartRate);
            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
            return ret;
        }

        public static int PER_FREGMENT_SIZE
        {
            get
            {
                int ret = HNAlgoNativePINVOKE.PER_FREGMENT_SIZE_get();
                return ret;
            }
        }

        public static int FCG_DATA_SIZE
        {
            get
            {
                int ret = HNAlgoNativePINVOKE.FCG_DATA_SIZE_get();
                return ret;
            }
        }

        public unsafe static void Spectrum2Analyse(HeartBeatInfoVector hbiv, double[] limbLead, double[] chestLead, int dataLength, double[] Gxx, double[] Gyy, double[] Qxy, double[] PIH, PSD_SPAC spacGxx, PSD_SPAC spacGyy, PSD_PIHAC pihAC, string strQxy)
        {
            fixed (double* swig_ptrTo_limbLead = limbLead)
            {
                fixed (double* swig_ptrTo_chestLead = chestLead)
                {
                    fixed (double* swig_ptrTo_Gxx = Gxx)
                    {
                        fixed (double* swig_ptrTo_Gyy = Gyy)
                        {
                            fixed (double* swig_ptrTo_Qxy = Qxy)
                            {
                                fixed (double* swig_ptrTo_PIH = PIH)
                                {
                                    {
                                        HNAlgoNativePINVOKE.Spectrum2Analyse(HeartBeatInfoVector.getCPtr(hbiv), (global::System.IntPtr)swig_ptrTo_limbLead, (global::System.IntPtr)swig_ptrTo_chestLead, dataLength, (global::System.IntPtr)swig_ptrTo_Gxx, (global::System.IntPtr)swig_ptrTo_Gyy, (global::System.IntPtr)swig_ptrTo_Qxy, (global::System.IntPtr)swig_ptrTo_PIH, PSD_SPAC.getCPtr(spacGxx), PSD_SPAC.getCPtr(spacGyy), PSD_PIHAC.getCPtr(pihAC), strQxy);
                                        if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        public unsafe static void CalculateSingleLeadGxx(double[] leadData, int dataLength, double[] Gxx)
        {
            fixed (double* swig_ptrTo_leadData = leadData)
            {
                fixed (double* swig_ptrTo_Gxx = Gxx)
                {
                    {
                        HNAlgoNativePINVOKE.CalculateSingleLeadGxx((global::System.IntPtr)swig_ptrTo_leadData, dataLength, (global::System.IntPtr)swig_ptrTo_Gxx);
                    }
                }
            }
        }

        public unsafe static uint FindAllHeartBeats(HeartBeatInfoVector heartBeatInfoVector, int longLead, int dataLength, double[] lead0, double[] lead1, double[] lead2, double[] lead3, double[] lead4, double[] lead5, double[] lead6, double[] lead7, double[] lead8, double[] lead9, double[] lead10, double[] lead11, double[] lead12, double[] lead13, double[] lead14, double[] lead15, double[] lead16, double[] lead17)
        {
            fixed (double* swig_ptrTo_lead0 = lead0)
            {
                fixed (double* swig_ptrTo_lead1 = lead1)
                {
                    fixed (double* swig_ptrTo_lead2 = lead2)
                    {
                        fixed (double* swig_ptrTo_lead3 = lead3)
                        {
                            fixed (double* swig_ptrTo_lead4 = lead4)
                            {
                                fixed (double* swig_ptrTo_lead5 = lead5)
                                {
                                    fixed (double* swig_ptrTo_lead6 = lead6)
                                    {
                                        fixed (double* swig_ptrTo_lead7 = lead7)
                                        {
                                            fixed (double* swig_ptrTo_lead8 = lead8)
                                            {
                                                fixed (double* swig_ptrTo_lead9 = lead9)
                                                {
                                                    fixed (double* swig_ptrTo_lead10 = lead10)
                                                    {
                                                        fixed (double* swig_ptrTo_lead11 = lead11)
                                                        {
                                                            fixed (double* swig_ptrTo_lead12 = lead12)
                                                            {
                                                                fixed (double* swig_ptrTo_lead13 = lead13)
                                                                {
                                                                    fixed (double* swig_ptrTo_lead14 = lead14)
                                                                    {
                                                                        fixed (double* swig_ptrTo_lead15 = lead15)
                                                                        {
                                                                            fixed (double* swig_ptrTo_lead16 = lead16)
                                                                            {
                                                                                fixed (double* swig_ptrTo_lead17 = lead17)
                                                                                {
                                                                                    {
                                                                                        uint ret = HNAlgoNativePINVOKE.FindAllHeartBeats(HeartBeatInfoVector.getCPtr(heartBeatInfoVector), longLead, dataLength, (global::System.IntPtr)swig_ptrTo_lead0, (global::System.IntPtr)swig_ptrTo_lead1, (global::System.IntPtr)swig_ptrTo_lead2, (global::System.IntPtr)swig_ptrTo_lead3, (global::System.IntPtr)swig_ptrTo_lead4, (global::System.IntPtr)swig_ptrTo_lead5, (global::System.IntPtr)swig_ptrTo_lead6, (global::System.IntPtr)swig_ptrTo_lead7, (global::System.IntPtr)swig_ptrTo_lead8, (global::System.IntPtr)swig_ptrTo_lead9, (global::System.IntPtr)swig_ptrTo_lead10, (global::System.IntPtr)swig_ptrTo_lead11, (global::System.IntPtr)swig_ptrTo_lead12, (global::System.IntPtr)swig_ptrTo_lead13, (global::System.IntPtr)swig_ptrTo_lead14, (global::System.IntPtr)swig_ptrTo_lead15, (global::System.IntPtr)swig_ptrTo_lead16, (global::System.IntPtr)swig_ptrTo_lead17);
                                                                                        if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
                                                                                        return ret;
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        public unsafe static uint GetPace(PaceBeatInfoVector PACE, double[] data, int dataLength, int lead, int fs, bool init)
        {
            fixed (double* swig_ptrTo_data = data)
            {
                {
                    uint ret = HNAlgoNativePINVOKE.GetPace__SWIG_0(PaceBeatInfoVector.getCPtr(PACE), (global::System.IntPtr)swig_ptrTo_data, dataLength, lead, fs, init);
                    if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
                    return ret;
                }
            }
        }

        public unsafe static uint GetPace(PaceBeatInfoVector PACE, double[] data, int dataLength, int lead, int fs)
        {
            fixed (double* swig_ptrTo_data = data)
            {
                {
                    uint ret = HNAlgoNativePINVOKE.GetPace__SWIG_1(PaceBeatInfoVector.getCPtr(PACE), (global::System.IntPtr)swig_ptrTo_data, dataLength, lead, fs);
                    if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
                    return ret;
                }
            }
        }

        public unsafe static uint FindAllFrankHeartBeats(HeartBeatInfoVector hbiv, uint dataLength, double[] X, double[] Y, double[] Z)
        {
            fixed (double* swig_ptrTo_X = X)
            {
                fixed (double* swig_ptrTo_Y = Y)
                {
                    fixed (double* swig_ptrTo_Z = Z)
                    {
                        {
                            uint ret = HNAlgoNativePINVOKE.FindAllFrankHeartBeats(HeartBeatInfoVector.getCPtr(hbiv), dataLength, (global::System.IntPtr)swig_ptrTo_X, (global::System.IntPtr)swig_ptrTo_Y, (global::System.IntPtr)swig_ptrTo_Z);
                            if (HNAlgoNativePINVOKE.SWIGPendingException.Pending) throw HNAlgoNativePINVOKE.SWIGPendingException.Retrieve();
                            return ret;
                        }
                    }
                }
            }
        }

    }

}

